diff --git a/.editorconfig b/.editorconfig
index 94bc4cb..935e327 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -116,6 +116,8 @@ csharp_space_between_method_call_parameter_list_parentheses = false:error
 csharp_preserve_single_line_statements = false:error
 csharp_preserve_single_line_blocks = true:error
 
+csharp_style_namespace_declarations = file_scoped
+
 # Resharper
 resharper_csharp_braces_for_lock=required_for_complex
 resharper_csharp_braces_for_using=required_for_complex
diff --git a/README.md b/README.md
index 51ac03d..989137d 100644
--- a/README.md
+++ b/README.md
@@ -30,7 +30,7 @@ var response = transport.Get<StringResponse>("/");
 var headResponse = transport.Head("/");
 ```
 
-`Get` and `Head` are extension methods to  the only method `ITransport` dictates namely `Request()` and its async variant.
+`Get` and `Head` are extension methods to  the only method `HttpTransport` dictates namely `Request()` and its async variant.
 
 Wrapping clients most likely will list out all `components` explicitly and use `Transport<TConfiguration>`
 
@@ -52,9 +52,9 @@ This allows implementers to extend `TransportConfiguration` with product/service
 
 ### Components
 
-`ITransport` itself only defines `Request()` and `RequestAsync()` and all wrapping clients accept an `ITransport`.
+`HttpTransport` itself only defines `Request()` and `RequestAsync()` and all wrapping clients accept an `HttpTransport`.
 
-The `ITransport` implementation that this library ships models a request pipeline that can deal with a large variety of topologies
+The `HttpTransport` implementation that this library ships models a request pipeline that can deal with a large variety of topologies
 
 ![request-pipeline.png](request-pipeline.png)
 
@@ -96,7 +96,7 @@ the `IConnectionPool` to the transport configuration
 ONLY if a connection pool indicates it supports receiving new nodes will the transport sniff.
 * `IConnection`  
 Abstraction for the actual IO the transport needs to perform. 
-* `ITransportSerializer`  
+* `HttpTransportSerializer`  
 Allows you to inject your own serializer, the default uses `System.Text.Json`
 * `IProductRegistration`  
 Product specific implementations and metadata provider
@@ -106,24 +106,24 @@ Product specific implementations and metadata provider
 
 * `ITransportConfigurationValues`  
 A transport configuration instance, explictly designed for clients to introduce subclasses of
-* `IRequestPipelineFactory`
-A factory creating `IRequestPipeline` instances
-* `IDateTimeProvider`
+* `RequestPipelineFactory`
+A factory creating `RequestPipeline` instances
+* `DateTimeProvider`
 Abstraction around the static `DateTime.Now` so we can test algorithms without waiting on the clock on the wall.
-* `IMemoryStreamFactory`
+* `MemoryStreamFactory`
 A factory creating `MemoryStream` instances.
 
 
 
 ### Observability
 
-The default `ITransport` implementation ships with various `DiagnosticSources` to make the whole 
+The default `HttpTransport` implementation ships with various `DiagnosticSources` to make the whole 
 flow through the request pipeline auditable and debuggable.  
 
-Every response returned by `Transport` has to implement `ITransportResponse` which has one property `ApiCall` of 
-type `IApiCallDetails` which in turns holds all information relevant to the request and response. 
+Every response returned by `Transport` has to implement `TransportResponse` which has one property `ApiCall` of 
+type `ApiCallDetails` which in turns holds all information relevant to the request and response. 
 
-`NOTE:` it also exposes `response.ApiCall.DebugInformation` always holds a human readable string to indicate 
+`NOTE:` it also exposes `response.ApiCallDetails.DebugInformation` always holds a human readable string to indicate 
 what happened.
 
 Further more `DiagnosticSources` exists for various purposes e.g (de)serialization times, time to first byte & various counters
diff --git a/benchmarks/Elastic.Transport.Benchmarks/TransportBenchmarks.cs b/benchmarks/Elastic.Transport.Benchmarks/TransportBenchmarks.cs
index 6a4f3f7..ff77561 100644
--- a/benchmarks/Elastic.Transport.Benchmarks/TransportBenchmarks.cs
+++ b/benchmarks/Elastic.Transport.Benchmarks/TransportBenchmarks.cs
@@ -10,7 +10,7 @@ namespace Elastic.Transport.Benchmarks
 {
 	public class TransportBenchmarks
 	{
-		private Transport _transport;
+		private DefaultHttpTransport _transport;
 
 		[GlobalSetup]
 		public void Setup()
@@ -19,7 +19,7 @@ public void Setup()
 			var pool = new SingleNodePool(new Uri("http://localhost:9200"));
 			var settings = new TransportConfiguration(pool, connection);
 
-			_transport = new Transport(settings);
+			_transport = new DefaultHttpTransport(settings);
 		}
 
 		[Benchmark]
@@ -28,9 +28,11 @@ public void Setup()
 		[Benchmark]
 		public async Task TransportSuccessfulAsyncRequestBenchmark() => await _transport.GetAsync<EmptyResponse>("/");
 
-		private class EmptyResponse : ITransportResponse
+		private class EmptyResponse : TransportResponse
 		{
-			public IApiCallDetails ApiCall { get; set; }
+			public EmptyResponse() : base() { }
+
+			public ApiCallDetails ApiCall { get; set; }
 		}
 	}
 }
diff --git a/benchmarks/Elastic.Transport.Profiling/Program.cs b/benchmarks/Elastic.Transport.Profiling/Program.cs
index e620851..9543339 100644
--- a/benchmarks/Elastic.Transport.Profiling/Program.cs
+++ b/benchmarks/Elastic.Transport.Profiling/Program.cs
@@ -17,7 +17,7 @@ private static async Task Main()
 			MemoryProfiler.GetSnapshot("start");
 
 			var config = new TransportConfiguration(new Uri("http://localhost:9200"), new ElasticsearchProductRegistration());
-			var transport = new Transport(config);
+			var transport = new DefaultHttpTransport(config);
 
 			_ = await transport.GetAsync<VoidResponse>("/");
 
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index 089c230..7e33d2f 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -18,7 +18,7 @@
 
     <InheritDocEnabled>true</InheritDocEnabled>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    
+    <ExposedPublicKey>002400000480000094000000060200000024000052534131000400000100010015b0fa59d868c7f3ea2ae67567b19e102465745f01b430a38a42b92fd41a0f5869bec1f2b33b589d78662af432fe6b789ef72d4738f7b1a86264d7aeb5185ed8995b2bb104e7c5c58845f1a618be829e410fa34a6bd7d714ece191ed68a66333a83ae7456ee32e9aeb54bc1d7410ae8c344367257e9001abb5e96ce1f1d97696</ExposedPublicKey>
   </PropertyGroup>
   
   <ItemGroup>
diff --git a/src/Elastic.Transport.VirtualizedCluster/Audit/Auditor.cs b/src/Elastic.Transport.VirtualizedCluster/Audit/Auditor.cs
index b5e39a2..5a61bfd 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Audit/Auditor.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Audit/Auditor.cs
@@ -10,294 +10,292 @@
 using Elastic.Transport.Extensions;
 using Elastic.Transport.VirtualizedCluster.Extensions;
 
-namespace Elastic.Transport.VirtualizedCluster.Audit
-{
-	public class Auditor
-	{
-		private Components.VirtualizedCluster _cluster;
-		private Components.VirtualizedCluster _clusterAsync;
+namespace Elastic.Transport.VirtualizedCluster.Audit;
 
-		public Auditor(Func<Components.VirtualizedCluster> setup) => Cluster = setup;
+public sealed class Auditor
+{
+	private Components.VirtualizedCluster _cluster;
+	private Components.VirtualizedCluster _clusterAsync;
 
-		private Auditor(Components.VirtualizedCluster cluster, Components.VirtualizedCluster clusterAsync)
-		{
-			_cluster = cluster;
-			_clusterAsync = clusterAsync;
-			StartedUp = true;
-		}
+	public Auditor(Func<Components.VirtualizedCluster> setup) => Cluster = setup;
 
-		public Action<NodePool> AssertPoolAfterCall { get; set; }
-		public Action<NodePool> AssertPoolAfterStartup { get; set; }
+	private Auditor(Components.VirtualizedCluster cluster, Components.VirtualizedCluster clusterAsync)
+	{
+		_cluster = cluster;
+		_clusterAsync = clusterAsync;
+		StartedUp = true;
+	}
 
-		public Action<NodePool> AssertPoolBeforeCall { get; set; }
-		public Action<NodePool> AssertPoolBeforeStartup { get; set; }
+	public Action<NodePool> AssertPoolAfterCall { get; set; }
+	public Action<NodePool> AssertPoolAfterStartup { get; set; }
 
-		public IEnumerable<Diagnostics.Auditing.Audit> AsyncAuditTrail { get; set; }
-		public IEnumerable<Diagnostics.Auditing.Audit> AuditTrail { get; set; }
-		public Func<Components.VirtualizedCluster> Cluster { get; set; }
+	public Action<NodePool> AssertPoolBeforeCall { get; set; }
+	public Action<NodePool> AssertPoolBeforeStartup { get; set; }
 
-		public ITransportResponse Response { get; internal set; }
-		public ITransportResponse ResponseAsync { get; internal set; }
+	public IEnumerable<Diagnostics.Auditing.Audit> AsyncAuditTrail { get; set; }
+	public IEnumerable<Diagnostics.Auditing.Audit> AuditTrail { get; set; }
+	public Func<Components.VirtualizedCluster> Cluster { get; set; }
 
-		private bool StartedUp { get; }
+	public TransportResponse Response { get; internal set; }
+	public TransportResponse ResponseAsync { get; internal set; }
 
+	private bool StartedUp { get; }
 
-		public void ChangeTime(Func<DateTime, DateTime> selector)
-		{
-			_cluster ??= Cluster();
-			_clusterAsync ??= Cluster();
+	public void ChangeTime(Func<DateTime, DateTime> selector)
+	{
+		_cluster ??= Cluster();
+		_clusterAsync ??= Cluster();
 
-			_cluster.ChangeTime(selector);
-			_clusterAsync.ChangeTime(selector);
-		}
+		_cluster.ChangeTime(selector);
+		_clusterAsync.ChangeTime(selector);
+	}
 
-		public async Task<Auditor> TraceStartup(ClientCall callTrace = null)
-		{
-			//synchronous code path
-			_cluster = _cluster ?? Cluster();
-			if (!StartedUp) AssertPoolBeforeStartup?.Invoke(_cluster.ConnectionPool);
-			AssertPoolBeforeCall?.Invoke(_cluster.ConnectionPool);
-			Response = _cluster.ClientCall(callTrace?.RequestOverrides);
-			AuditTrail = Response.ApiCall.AuditTrail;
-			if (!StartedUp) AssertPoolAfterStartup?.Invoke(_cluster.ConnectionPool);
-			AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
-
-			//async code path
-			_clusterAsync = _clusterAsync ?? Cluster();
-			if (!StartedUp) AssertPoolBeforeStartup?.Invoke(_clusterAsync.ConnectionPool);
-			AssertPoolBeforeCall?.Invoke(_clusterAsync.ConnectionPool);
-			ResponseAsync = await _clusterAsync.ClientCallAsync(callTrace?.RequestOverrides).ConfigureAwait(false);
-			AsyncAuditTrail = ResponseAsync.ApiCall.AuditTrail;
-			if (!StartedUp) AssertPoolAfterStartup?.Invoke(_clusterAsync.ConnectionPool);
-			AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
-			return new Auditor(_cluster, _clusterAsync);
-		}
+	public async Task<Auditor> TraceStartup(ClientCall callTrace = null)
+	{
+		//synchronous code path
+		_cluster ??= Cluster();
+		if (!StartedUp) AssertPoolBeforeStartup?.Invoke(_cluster.ConnectionPool);
+		AssertPoolBeforeCall?.Invoke(_cluster.ConnectionPool);
+		Response = _cluster.ClientCall(callTrace?.RequestOverrides);
+		AuditTrail = Response.ApiCallDetails.AuditTrail;
+		if (!StartedUp) AssertPoolAfterStartup?.Invoke(_cluster.ConnectionPool);
+		AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
+
+		//async code path
+		_clusterAsync ??= Cluster();
+		if (!StartedUp) AssertPoolBeforeStartup?.Invoke(_clusterAsync.ConnectionPool);
+		AssertPoolBeforeCall?.Invoke(_clusterAsync.ConnectionPool);
+		ResponseAsync = await _clusterAsync.ClientCallAsync(callTrace?.RequestOverrides).ConfigureAwait(false);
+		AsyncAuditTrail = ResponseAsync.ApiCallDetails.AuditTrail;
+		if (!StartedUp) AssertPoolAfterStartup?.Invoke(_clusterAsync.ConnectionPool);
+		AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
+		return new Auditor(_cluster, _clusterAsync);
+	}
 
-		public async Task<Auditor> TraceCall(ClientCall callTrace, int nthCall = 0)
-		{
-			await TraceStartup(callTrace).ConfigureAwait(false);
-			return AssertAuditTrails(callTrace, nthCall);
-		}
+	public async Task<Auditor> TraceCall(ClientCall callTrace, int nthCall = 0)
+	{
+		await TraceStartup(callTrace).ConfigureAwait(false);
+		return AssertAuditTrails(callTrace, nthCall);
+	}
 
 #pragma warning disable 1998 // Async method lacks 'await' operators and will run synchronously
-		private async Task TraceException<TException>(ClientCall callTrace, Action<TException> assert)
+	private async Task TraceException<TException>(ClientCall callTrace, Action<TException> assert)
 #pragma warning restore 1998 // Async method lacks 'await' operators and will run synchronously
-			where TException : TransportException
-		{
-			_cluster = _cluster ?? Cluster();
-			_cluster.ClientThrows(true);
-			AssertPoolBeforeCall?.Invoke(_cluster.ConnectionPool);
+		where TException : TransportException
+	{
+		_cluster ??= Cluster();
+		_cluster.ClientThrows(true);
+		AssertPoolBeforeCall?.Invoke(_cluster.ConnectionPool);
 
-			Action call = () => Response = _cluster.ClientCall(callTrace?.RequestOverrides);
-			var exception = TryCall(call, assert);
-			assert(exception);
+		Action call = () => Response = _cluster.ClientCall(callTrace?.RequestOverrides);
+		var exception = TryCall(call, assert);
+		assert(exception);
 
-			AuditTrail = exception.AuditTrail;
-			AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
+		AuditTrail = exception.AuditTrail;
+		AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
 
-			_clusterAsync = _clusterAsync ?? Cluster();
-			_clusterAsync.ClientThrows(true);
-			Func<Task> callAsync = async () => ResponseAsync = await _clusterAsync.ClientCallAsync(callTrace?.RequestOverrides).ConfigureAwait(false);
-			exception = await TryCallAsync(callAsync, assert).ConfigureAwait(false);
-			assert(exception);
+		_clusterAsync ??= Cluster();
+		_clusterAsync.ClientThrows(true);
+		Func<Task> callAsync = async () => ResponseAsync = await _clusterAsync.ClientCallAsync(callTrace?.RequestOverrides).ConfigureAwait(false);
+		exception = await TryCallAsync(callAsync, assert).ConfigureAwait(false);
+		assert(exception);
 
-			AsyncAuditTrail = exception.AuditTrail;
-			AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
-		}
+		AsyncAuditTrail = exception.AuditTrail;
+		AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
+	}
 
-		public async Task<Auditor> TraceElasticsearchException(ClientCall callTrace, Action<TransportException> assert)
-		{
-			await TraceException(callTrace, assert).ConfigureAwait(false);
-			var audit = new Auditor(_cluster, _clusterAsync);
-			return await audit.TraceElasticsearchExceptionOnResponse(callTrace, assert).ConfigureAwait(false);
-		}
+	public async Task<Auditor> TraceElasticsearchException(ClientCall callTrace, Action<TransportException> assert)
+	{
+		await TraceException(callTrace, assert).ConfigureAwait(false);
+		var audit = new Auditor(_cluster, _clusterAsync);
+		return await audit.TraceElasticsearchExceptionOnResponse(callTrace, assert).ConfigureAwait(false);
+	}
 
-		public async Task<Auditor> TraceUnexpectedTransportException(ClientCall callTrace, Action<UnexpectedTransportException> assert)
-		{
-			await TraceException(callTrace, assert).ConfigureAwait(false);
-			return new Auditor(_cluster, _clusterAsync);
-		}
+	public async Task<Auditor> TraceUnexpectedTransportException(ClientCall callTrace, Action<UnexpectedTransportException> assert)
+	{
+		await TraceException(callTrace, assert).ConfigureAwait(false);
+		return new Auditor(_cluster, _clusterAsync);
+	}
 
 #pragma warning disable 1998
-		public async Task<Auditor> TraceElasticsearchExceptionOnResponse(ClientCall callTrace, Action<TransportException> assert)
+	public async Task<Auditor> TraceElasticsearchExceptionOnResponse(ClientCall callTrace, Action<TransportException> assert)
 #pragma warning restore 1998
-		{
-			_cluster = _cluster ?? Cluster();
-			_cluster.ClientThrows(false);
-			AssertPoolBeforeCall?.Invoke(_cluster.ConnectionPool);
+	{
+		_cluster ??= Cluster();
+		_cluster.ClientThrows(false);
+		AssertPoolBeforeCall?.Invoke(_cluster.ConnectionPool);
 
-			Action call = () => { Response = _cluster.ClientCall(callTrace?.RequestOverrides); };
-			call();
+		Action call = () => { Response = _cluster.ClientCall(callTrace?.RequestOverrides); };
+		call();
 
-			if (Response.ApiCall.Success) throw new Exception("Expected call to not be valid");
+		if (Response.ApiCallDetails.Success) throw new Exception("Expected call to not be valid");
 
-			if (Response.ApiCall.OriginalException is not TransportException exception)
-				throw new Exception("OriginalException on response is not expected TransportException");
+		if (Response.ApiCallDetails.OriginalException is not TransportException exception)
+			throw new Exception("OriginalException on response is not expected TransportException");
 
-			assert(exception);
+		assert(exception);
 
-			AuditTrail = exception.AuditTrail;
-			AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
+		AuditTrail = exception.AuditTrail;
+		AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
 
-			_clusterAsync = _clusterAsync ?? Cluster();
-			_clusterAsync.ClientThrows(false);
-			Func<Task> callAsync = async () => { ResponseAsync = await _clusterAsync.ClientCallAsync(callTrace?.RequestOverrides).ConfigureAwait(false); };
-			await callAsync().ConfigureAwait(false);
-			if (Response.ApiCall.Success) throw new Exception("Expected call to not be valid");
-			exception = ResponseAsync.ApiCall.OriginalException as TransportException;
-			if (exception == null) throw new Exception("OriginalException on response is not expected TransportException");
-			assert(exception);
+		_clusterAsync ??= Cluster();
+		_clusterAsync.ClientThrows(false);
+		Func<Task> callAsync = async () => { ResponseAsync = await _clusterAsync.ClientCallAsync(callTrace?.RequestOverrides).ConfigureAwait(false); };
+		await callAsync().ConfigureAwait(false);
+		if (Response.ApiCallDetails.Success) throw new Exception("Expected call to not be valid");
+		exception = ResponseAsync.ApiCallDetails.OriginalException as TransportException;
+		if (exception == null) throw new Exception("OriginalException on response is not expected TransportException");
+		assert(exception);
 
-			AsyncAuditTrail = exception.AuditTrail;
-			AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
-			var audit = new Auditor(_cluster, _clusterAsync);
+		AsyncAuditTrail = exception.AuditTrail;
+		AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
+		var audit = new Auditor(_cluster, _clusterAsync);
 
-			return audit;
-		}
+		return audit;
+	}
 
 #pragma warning disable 1998
-		public async Task<Auditor> TraceUnexpectedException(ClientCall callTrace, Action<UnexpectedTransportException> assert)
+	public async Task<Auditor> TraceUnexpectedException(ClientCall callTrace, Action<UnexpectedTransportException> assert)
 #pragma warning restore 1998
-		{
-			_cluster = _cluster ?? Cluster();
-			AssertPoolBeforeCall?.Invoke(_cluster.ConnectionPool);
+	{
+		_cluster ??= Cluster();
+		AssertPoolBeforeCall?.Invoke(_cluster.ConnectionPool);
 
-			Action call = () => Response = _cluster.ClientCall(callTrace?.RequestOverrides);
-			var exception = TryCall(call, assert);
-			assert(exception);
+		Action call = () => Response = _cluster.ClientCall(callTrace?.RequestOverrides);
+		var exception = TryCall(call, assert);
+		assert(exception);
 
-			AuditTrail = exception.AuditTrail;
-			AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
+		AuditTrail = exception.AuditTrail;
+		AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
 
-			_clusterAsync = _clusterAsync ?? Cluster();
-			Func<Task> callAsync = async () => ResponseAsync = await _clusterAsync.ClientCallAsync(callTrace?.RequestOverrides).ConfigureAwait(false);
-			exception = await TryCallAsync(callAsync, assert).ConfigureAwait(false);
-			assert(exception);
+		_clusterAsync ??= Cluster();
+		Func<Task> callAsync = async () => ResponseAsync = await _clusterAsync.ClientCallAsync(callTrace?.RequestOverrides).ConfigureAwait(false);
+		exception = await TryCallAsync(callAsync, assert).ConfigureAwait(false);
+		assert(exception);
 
-			AsyncAuditTrail = exception.AuditTrail;
-			AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
-			return new Auditor(_cluster, _clusterAsync);
-		}
+		AsyncAuditTrail = exception.AuditTrail;
+		AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
+		return new Auditor(_cluster, _clusterAsync);
+	}
 
-		private Auditor AssertAuditTrails(ClientCall callTrace, int nthCall)
-		{
-			var nl = Environment.NewLine;
+	private Auditor AssertAuditTrails(ClientCall callTrace, int nthCall)
+	{
+		var nl = Environment.NewLine;
 
-			if (AuditTrail is ICollection<Diagnostics.Auditing.Audit> at && AsyncAuditTrail is ICollection<Diagnostics.Auditing.Audit> ata && at.Count != ata.Count)
-				throw new Exception($"{nthCall} has a mismatch between sync and async. {nl}async:{AuditTrail}{nl}sync:{AsyncAuditTrail}");
-			else if (AuditTrail.Count() != AsyncAuditTrail.Count())
-				throw new Exception($"{nthCall} has a mismatch between sync and async. {nl}async:{AuditTrail}{nl}sync:{AsyncAuditTrail}");
+		if (AuditTrail is ICollection<Diagnostics.Auditing.Audit> at && AsyncAuditTrail is ICollection<Diagnostics.Auditing.Audit> ata && at.Count != ata.Count)
+			throw new Exception($"{nthCall} has a mismatch between sync and async. {nl}async:{AuditTrail}{nl}sync:{AsyncAuditTrail}");
+		else if (AuditTrail.Count() != AsyncAuditTrail.Count())
+			throw new Exception($"{nthCall} has a mismatch between sync and async. {nl}async:{AuditTrail}{nl}sync:{AsyncAuditTrail}");
 
-			AssertTrailOnResponse(callTrace, AuditTrail, true, nthCall);
-			AssertTrailOnResponse(callTrace, AuditTrail, false, nthCall);
+		AssertTrailOnResponse(callTrace, AuditTrail, true, nthCall);
+		AssertTrailOnResponse(callTrace, AuditTrail, false, nthCall);
 
-			callTrace.AssertResponse?.Invoke(Response);
-			callTrace.AssertResponse?.Invoke(ResponseAsync);
+		callTrace.AssertResponse?.Invoke(Response);
+		callTrace.AssertResponse?.Invoke(ResponseAsync);
 
-			callTrace.AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
-			callTrace.AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
-			return new Auditor(_cluster, _clusterAsync);
-		}
+		callTrace.AssertPoolAfterCall?.Invoke(_cluster.ConnectionPool);
+		callTrace.AssertPoolAfterCall?.Invoke(_clusterAsync.ConnectionPool);
+		return new Auditor(_cluster, _clusterAsync);
+	}
 
 
-		public void VisualizeCalls(int numberOfCalls)
+	public void VisualizeCalls(int numberOfCalls)
+	{
+		var cluster = _cluster ?? Cluster();
+		var messages = new List<string>(numberOfCalls * 2);
+		for (var i = 0; i < numberOfCalls; i++)
 		{
-			var cluster = _cluster ?? Cluster();
-			var messages = new List<string>(numberOfCalls * 2);
-			for (var i = 0; i < numberOfCalls; i++)
-			{
-				var call = cluster.ClientCall();
-				var d = call.ApiCall;
-				var actualAuditTrail = AuditTrailToString(d.AuditTrail);
-				messages.Add($"{d.HttpMethod.GetStringValue()} ({d.Uri.Port}) (status: {d.HttpStatusCode})");
-				messages.Add(actualAuditTrail);
-			}
-			throw new Exception(string.Join(Environment.NewLine, messages));
+			var call = cluster.ClientCall();
+			var d = call.ApiCallDetails;
+			var actualAuditTrail = AuditTrailToString(d.AuditTrail);
+			messages.Add($"{d.HttpMethod.GetStringValue()} ({d.Uri.Port}) (status: {d.HttpStatusCode})");
+			messages.Add(actualAuditTrail);
 		}
+		throw new Exception(string.Join(Environment.NewLine, messages));
+	}
+
+	private static string AuditTrailToString(IEnumerable<Diagnostics.Auditing.Audit> auditTrail)
+	{
+		var actualAuditTrail = auditTrail.Aggregate(new StringBuilder(),
+			(sb, a) => sb.AppendLine($"-> {a}"),
+			sb => sb.ToString());
+		return actualAuditTrail;
+	}
+
+	public async Task<Auditor> TraceCalls(params ClientCall[] audits)
+	{
+		var auditor = this;
+		foreach (var a in audits.Select((a, i) => new { a, i })) auditor = await auditor.TraceCall(a.a, a.i).ConfigureAwait(false);
+		return auditor;
+	}
+
+	private static void AssertTrailOnResponse(ClientCall callTrace, IEnumerable<Diagnostics.Auditing.Audit> auditTrail, bool sync, int nthCall)
+	{
+		var typeOfTrail = (sync ? "synchronous" : "asynchronous") + " audit trail";
+		var nthClientCall = (nthCall + 1).ToOrdinal();
+
+		var actualAuditTrail = auditTrail.Aggregate(new StringBuilder(Environment.NewLine),
+			(sb, a) => sb.AppendLine($"-> {a}"),
+			sb => sb.ToString());
+
+		var traceEvents = callTrace.Select(c => c.Event).ToList();
+		var auditEvents = auditTrail.Select(a => a.Event).ToList();
+		if (!traceEvents.SequenceEqual(auditEvents))
+			throw new Exception($"the {nthClientCall} client call's {typeOfTrail} should assert ALL audit trail items{actualAuditTrail}");
 
-		private static string AuditTrailToString(IEnumerable<Diagnostics.Auditing.Audit> auditTrail)
+		foreach (var t in auditTrail.Select((a, i) => new { a, i }))
 		{
-			var actualAuditTrail = auditTrail.Aggregate(new StringBuilder(),
-				(sb, a) => sb.AppendLine($"-> {a}"),
-				sb => sb.ToString());
-			return actualAuditTrail;
+			var i = t.i;
+			var audit = t.a;
+			var nthAuditTrailItem = (i + 1).ToOrdinal();
+			var because = $"thats the {{0}} specified on the {nthAuditTrailItem} item in the {nthClientCall} client call's {typeOfTrail}";
+			var c = callTrace[i];
+			if (audit.Event != c.Event)
+				throw new Exception(string.Format(because, "event"));
+			if (c.Port.HasValue && audit.Node.Uri.Port != c.Port.Value)
+				throw new Exception(string.Format(because, "port"));
+
+			c.SimpleAssert?.Invoke(audit);
+			c.AssertWithBecause?.Invoke(string.Format(because, "custom assertion"), audit);
 		}
 
-		public async Task<Auditor> TraceCalls(params ClientCall[] audits)
+		if (auditTrail is ICollection<Diagnostics.Auditing.Audit> at && callTrace.Count != at.Count)
+			throw new Exception($"callTrace has {callTrace.Count} items. Actual auditTrail {actualAuditTrail}");
+		else if (callTrace.Count != auditTrail.Count())
+			throw new Exception($"callTrace has {callTrace.Count} items. Actual auditTrail {actualAuditTrail}");
+	}
+
+	private static TException TryCall<TException>(Action call, Action<TException> assert) where TException : TransportException
+	{
+		TException exception = null;
+		try
 		{
-			var auditor = this;
-			foreach (var a in audits.Select((a, i) => new { a, i })) auditor = await auditor.TraceCall(a.a, a.i).ConfigureAwait(false);
-			return auditor;
+			call();
 		}
-
-		private static void AssertTrailOnResponse(ClientCall callTrace, IEnumerable<Diagnostics.Auditing.Audit> auditTrail, bool sync, int nthCall)
+		catch (TException ex)
 		{
-			var typeOfTrail = (sync ? "synchronous" : "asynchronous") + " audit trail";
-			var nthClientCall = (nthCall + 1).ToOrdinal();
-
-			var actualAuditTrail = auditTrail.Aggregate(new StringBuilder(Environment.NewLine),
-				(sb, a) => sb.AppendLine($"-> {a}"),
-				sb => sb.ToString());
-
-			var traceEvents =callTrace.Select(c => c.Event).ToList();
-			var auditEvents = auditTrail.Select(a => a.Event).ToList();
-			if (!traceEvents.SequenceEqual(auditEvents))
-				throw new Exception($"the {nthClientCall} client call's {typeOfTrail} should assert ALL audit trail items{actualAuditTrail}");
-
-			foreach (var t in auditTrail.Select((a, i) => new { a, i }))
-			{
-				var i = t.i;
-				var audit = t.a;
-				var nthAuditTrailItem = (i + 1).ToOrdinal();
-				var because = $"thats the {{0}} specified on the {nthAuditTrailItem} item in the {nthClientCall} client call's {typeOfTrail}";
-				var c = callTrace[i];
-				if (audit.Event != c.Event)
-					throw new Exception(string.Format(because, "event"));
-				if (c.Port.HasValue && audit.Node.Uri.Port != c.Port.Value)
-					throw new Exception(string.Format(because, "port"));
-
-				c.SimpleAssert?.Invoke(audit);
-				c.AssertWithBecause?.Invoke(string.Format(because, "custom assertion"), audit);
-			}
-
-			if (auditTrail is ICollection<Diagnostics.Auditing.Audit> at && callTrace.Count != at.Count)
-				throw new Exception($"callTrace has {callTrace.Count} items. Actual auditTrail {actualAuditTrail}");
-			else if (callTrace.Count != auditTrail.Count())
-				throw new Exception($"callTrace has {callTrace.Count} items. Actual auditTrail {actualAuditTrail}");
+			exception = ex;
+			assert(ex);
 		}
+		if (exception is null) throw new Exception("No exception happened while one was expected");
 
-		private static TException TryCall<TException>(Action call, Action<TException> assert) where TException : TransportException
+		return exception;
+	}
+	private static async Task<TException> TryCallAsync<TException>(Func<Task> call, Action<TException> assert) where TException : TransportException
+	{
+		TException exception = null;
+		try
 		{
-			TException exception = null;
-			try
-			{
-				call();
-			}
-			catch (TException ex)
-			{
-				exception = ex;
-				assert(ex);
-			}
-			if (exception is null) throw new Exception("No exception happened while one was expected");
-
-			return exception;
+			await call().ConfigureAwait(false);
 		}
-		private static async Task<TException> TryCallAsync<TException>(Func<Task> call, Action<TException> assert) where TException : TransportException
+		catch (TException ex)
 		{
-			TException exception = null;
-			try
-			{
-				await call().ConfigureAwait(false);
-			}
-			catch (TException ex)
-			{
-				exception = ex;
-				assert(ex);
-			}
-			if (exception is null) throw new Exception("No exception happened while one was expected");
-
-			return exception;
+			exception = ex;
+			assert(ex);
 		}
+		if (exception is null) throw new Exception("No exception happened while one was expected");
 
+		return exception;
 	}
+
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Audit/Audits.cs b/src/Elastic.Transport.VirtualizedCluster/Audit/Audits.cs
deleted file mode 100644
index 10ed674..0000000
--- a/src/Elastic.Transport.VirtualizedCluster/Audit/Audits.cs
+++ /dev/null
@@ -1,48 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System;
-using System.Collections.Generic;
-using Elastic.Transport.Diagnostics.Auditing;
-
-namespace Elastic.Transport.VirtualizedCluster.Audit
-{
-	public class CallTraceState
-	{
-		public CallTraceState(AuditEvent e) => Event = e;
-
-		public Action<string, Elastic.Transport.Diagnostics.Auditing.Audit> AssertWithBecause { get; set; }
-
-		public AuditEvent Event { get; private set; }
-
-		public int? Port { get; set; }
-
-		public Action<Elastic.Transport.Diagnostics.Auditing.Audit> SimpleAssert { get; set; }
-	}
-
-	public class ClientCall : List<CallTraceState>
-	{
-		public ClientCall() { }
-
-		public ClientCall(Func<RequestConfigurationDescriptor, IRequestConfiguration> requestOverrides) => RequestOverrides = requestOverrides;
-
-		public Action<NodePool> AssertPoolAfterCall { get; private set; }
-		public Action<ITransportResponse> AssertResponse { get; private set; }
-		public Func<RequestConfigurationDescriptor, IRequestConfiguration> RequestOverrides { get; }
-
-		public void Add(AuditEvent key, Action<Elastic.Transport.Diagnostics.Auditing.Audit> value) => Add(new CallTraceState(key) { SimpleAssert = value });
-
-		public void Add(AuditEvent key, int port) => Add(new CallTraceState(key) { Port = port });
-
-		public void Add(AuditEvent key) => Add(new CallTraceState(key));
-
-		public void Add(Action<NodePool> pool) => AssertPoolAfterCall = pool;
-
-		public void Add(AuditEvent key, int port, Action<ITransportResponse> assertResponse)
-		{
-			Add(new CallTraceState(key) { Port = port });
-			AssertResponse = assertResponse;
-		}
-	}
-}
diff --git a/src/Elastic.Transport.VirtualizedCluster/Audit/CallTraceState.cs b/src/Elastic.Transport.VirtualizedCluster/Audit/CallTraceState.cs
new file mode 100644
index 0000000..52af62f
--- /dev/null
+++ b/src/Elastic.Transport.VirtualizedCluster/Audit/CallTraceState.cs
@@ -0,0 +1,21 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System;
+using Elastic.Transport.Diagnostics.Auditing;
+
+namespace Elastic.Transport.VirtualizedCluster.Audit;
+
+public sealed class CallTraceState
+{
+	public CallTraceState(AuditEvent e) => Event = e;
+
+	public Action<string, Transport.Diagnostics.Auditing.Audit> AssertWithBecause { get; set; }
+
+	public AuditEvent Event { get; private set; }
+
+	public int? Port { get; set; }
+
+	public Action<Transport.Diagnostics.Auditing.Audit> SimpleAssert { get; set; }
+}
diff --git a/src/Elastic.Transport.VirtualizedCluster/Audit/ClientCall.cs b/src/Elastic.Transport.VirtualizedCluster/Audit/ClientCall.cs
new file mode 100644
index 0000000..b10ab8b
--- /dev/null
+++ b/src/Elastic.Transport.VirtualizedCluster/Audit/ClientCall.cs
@@ -0,0 +1,34 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System;
+using System.Collections.Generic;
+using Elastic.Transport.Diagnostics.Auditing;
+
+namespace Elastic.Transport.VirtualizedCluster.Audit;
+
+public sealed class ClientCall : List<CallTraceState>
+{
+	public ClientCall() { }
+
+	public ClientCall(Func<RequestConfigurationDescriptor, IRequestConfiguration> requestOverrides) => RequestOverrides = requestOverrides;
+
+	public Action<NodePool> AssertPoolAfterCall { get; private set; }
+	public Action<TransportResponse> AssertResponse { get; private set; }
+	public Func<RequestConfigurationDescriptor, IRequestConfiguration> RequestOverrides { get; }
+
+	public void Add(AuditEvent key, Action<Elastic.Transport.Diagnostics.Auditing.Audit> value) => Add(new CallTraceState(key) { SimpleAssert = value });
+
+	public void Add(AuditEvent key, int port) => Add(new CallTraceState(key) { Port = port });
+
+	public void Add(AuditEvent key) => Add(new CallTraceState(key));
+
+	public void Add(Action<NodePool> pool) => AssertPoolAfterCall = pool;
+
+	public void Add(AuditEvent key, int port, Action<TransportResponse> assertResponse)
+	{
+		Add(new CallTraceState(key) { Port = port });
+		AssertResponse = assertResponse;
+	}
+}
diff --git a/src/Elastic.Transport.VirtualizedCluster/Components/ExposingPipelineFactory.cs b/src/Elastic.Transport.VirtualizedCluster/Components/ExposingPipelineFactory.cs
index 389eb5f..7bee834 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Components/ExposingPipelineFactory.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Components/ExposingPipelineFactory.cs
@@ -2,35 +2,30 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport.VirtualizedCluster.Components
+namespace Elastic.Transport.VirtualizedCluster.Components;
+
+/// <summary>
+/// An implementation that exposes all the components so that <see cref="VirtualCluster"/> can reference them directly.
+/// </summary>
+public sealed class ExposingPipelineFactory<TConfiguration> : RequestPipelineFactory<TConfiguration> where TConfiguration : class, ITransportConfiguration
 {
-	/// <summary>
-	/// An implementation that exposes all the components so that <see cref="VirtualCluster"/> can reference them directly.
-	/// </summary>
-	public class ExposingPipelineFactory<TConfiguration> : IRequestPipelineFactory<TConfiguration> where TConfiguration : class, ITransportConfiguration
+	public ExposingPipelineFactory(TConfiguration connectionSettings, DateTimeProvider dateTimeProvider)
 	{
-		public ExposingPipelineFactory(TConfiguration connectionSettings, IDateTimeProvider dateTimeProvider)
-		{
-			DateTimeProvider = dateTimeProvider;
-			MemoryStreamFactory = TransportConfiguration.DefaultMemoryStreamFactory;
-
-			Settings = connectionSettings;
-			Pipeline = Create(Settings, DateTimeProvider, MemoryStreamFactory, new RequestParameters());
-			Transport = new Transport<TConfiguration>(Settings, this, DateTimeProvider, MemoryStreamFactory);
-		}
-
-		// ReSharper disable once MemberCanBePrivate.Global
-		public IRequestPipeline Pipeline { get; }
-
-		private IDateTimeProvider DateTimeProvider { get; }
-		private IMemoryStreamFactory MemoryStreamFactory { get; }
-		private TConfiguration Settings { get; }
-		public ITransport<ITransportConfiguration> Transport { get; }
+		DateTimeProvider = dateTimeProvider;
+		MemoryStreamFactory = TransportConfiguration.DefaultMemoryStreamFactory;
+		Settings = connectionSettings;
+		Pipeline = Create(Settings, DateTimeProvider, MemoryStreamFactory, new DefaultRequestParameters());
+		Transport = new DefaultHttpTransport<TConfiguration>(Settings, this, DateTimeProvider, MemoryStreamFactory);
+	}
 
+	// ReSharper disable once MemberCanBePrivate.Global
+	public RequestPipeline Pipeline { get; }
+	private DateTimeProvider DateTimeProvider { get; }
+	private MemoryStreamFactory MemoryStreamFactory { get; }
+	private TConfiguration Settings { get; }
+	public HttpTransport<TConfiguration> Transport { get; }
 
-		public IRequestPipeline Create(TConfiguration configurationValues, IDateTimeProvider dateTimeProvider,
-			IMemoryStreamFactory memoryStreamFactory, IRequestParameters requestParameters
-		) =>
-			new RequestPipeline<TConfiguration>(Settings, DateTimeProvider, MemoryStreamFactory, requestParameters ?? new RequestParameters());
-	}
+	public override RequestPipeline Create(TConfiguration configurationValues, DateTimeProvider dateTimeProvider,
+		MemoryStreamFactory memoryStreamFactory, RequestParameters requestParameters) =>
+			new DefaultRequestPipeline<TConfiguration>(Settings, DateTimeProvider, MemoryStreamFactory, requestParameters ?? new DefaultRequestParameters());
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Components/SealedVirtualCluster.cs b/src/Elastic.Transport.VirtualizedCluster/Components/SealedVirtualCluster.cs
index 5887610..5da5ee5 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Components/SealedVirtualCluster.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Components/SealedVirtualCluster.cs
@@ -6,46 +6,45 @@
 using Elastic.Transport.VirtualizedCluster.Products;
 using Elastic.Transport.VirtualizedCluster.Providers;
 
-namespace Elastic.Transport.VirtualizedCluster.Components
+namespace Elastic.Transport.VirtualizedCluster.Components;
+
+/// <summary>
+/// A continuation of <see cref="VirtualCluster"/>'s builder methods that creates
+/// an instance of <see cref="TransportConfiguration"/> for the cluster after which the components such as
+/// <see cref="TransportClient"/> and <see cref="NodePool"/> can no longer be updated.
+/// </summary>
+public sealed class SealedVirtualCluster
 {
-	/// <summary>
-	/// A continuation of <see cref="VirtualCluster"/>'s builder methods that creates
-	/// an instance of <see cref="TransportConfiguration"/> for the cluster after which the components such as
-	/// <see cref="ITransportClient"/> and <see cref="NodePool"/> can no longer be updated.
-	/// </summary>
-	public class SealedVirtualCluster
+	private readonly TransportClient _connection;
+	private readonly NodePool _connectionPool;
+	private readonly TestableDateTimeProvider _dateTimeProvider;
+	private readonly MockProductRegistration _productRegistration;
+
+	internal SealedVirtualCluster(VirtualCluster cluster, NodePool pool, TestableDateTimeProvider dateTimeProvider, MockProductRegistration productRegistration)
 	{
-		private readonly ITransportClient _connection;
-		private readonly NodePool _connectionPool;
-		private readonly TestableDateTimeProvider _dateTimeProvider;
-		private readonly IMockProductRegistration _productRegistration;
-
-		internal SealedVirtualCluster(VirtualCluster cluster, NodePool pool, TestableDateTimeProvider dateTimeProvider, IMockProductRegistration productRegistration)
-		{
-			_connectionPool = pool;
-			_connection = new VirtualClusterConnection(cluster, dateTimeProvider);
-			_dateTimeProvider = dateTimeProvider;
-			_productRegistration = productRegistration;
-		}
-
-		private TransportConfiguration CreateSettings() =>
-			new TransportConfiguration(_connectionPool, _connection, serializer: null, _productRegistration.ProductRegistration);
-
-		/// <summary> Create the cluster using all defaults on <see cref="TransportConfiguration"/> </summary>
-		public VirtualizedCluster AllDefaults() =>
-			new VirtualizedCluster(_dateTimeProvider, CreateSettings());
-
-		/// <summary> Create the cluster using <paramref name="selector"/> to provide configuration changes </summary>
-		/// <param name="selector">Provide custom configuration options</param>
-		public VirtualizedCluster Settings(Func<TransportConfiguration, TransportConfiguration> selector) =>
-			new VirtualizedCluster(_dateTimeProvider, selector(CreateSettings()));
-
-		/// <summary>
-		/// Allows you to create an instance of `<see cref="VirtualClusterConnection"/> using the DSL provided by <see cref="Virtual"/>
-		/// </summary>
-		/// <param name="selector">Provide custom configuration options</param>
-		public VirtualClusterConnection VirtualClusterConnection(Func<TransportConfiguration, TransportConfiguration> selector = null) =>
-			new VirtualizedCluster(_dateTimeProvider, selector == null ? CreateSettings() : selector(CreateSettings()))
-				.Connection;
+		_connectionPool = pool;
+		_connection = new VirtualClusterConnection(cluster, dateTimeProvider);
+		_dateTimeProvider = dateTimeProvider;
+		_productRegistration = productRegistration;
 	}
+
+	private TransportConfiguration CreateSettings() =>
+		new(_connectionPool, _connection, serializer: null, _productRegistration.ProductRegistration);
+
+	/// <summary> Create the cluster using all defaults on <see cref="TransportConfiguration"/> </summary>
+	public VirtualizedCluster AllDefaults() =>
+		new(_dateTimeProvider, CreateSettings());
+
+	/// <summary> Create the cluster using <paramref name="selector"/> to provide configuration changes </summary>
+	/// <param name="selector">Provide custom configuration options</param>
+	public VirtualizedCluster Settings(Func<TransportConfiguration, TransportConfiguration> selector) =>
+		new(_dateTimeProvider, selector(CreateSettings()));
+
+	/// <summary>
+	/// Allows you to create an instance of `<see cref="VirtualClusterConnection"/> using the DSL provided by <see cref="Virtual"/>
+	/// </summary>
+	/// <param name="selector">Provide custom configuration options</param>
+	public VirtualClusterConnection VirtualClusterConnection(Func<TransportConfiguration, TransportConfiguration> selector = null) =>
+		new VirtualizedCluster(_dateTimeProvider, selector == null ? CreateSettings() : selector(CreateSettings()))
+			.Connection;
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Components/VirtualCluster.cs b/src/Elastic.Transport.VirtualizedCluster/Components/VirtualCluster.cs
index 359a635..9f0ac77 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Components/VirtualCluster.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Components/VirtualCluster.cs
@@ -9,97 +9,96 @@
 using Elastic.Transport.VirtualizedCluster.Providers;
 using Elastic.Transport.VirtualizedCluster.Rules;
 
-namespace Elastic.Transport.VirtualizedCluster.Components
+namespace Elastic.Transport.VirtualizedCluster.Components;
+
+public class VirtualCluster
 {
-	public class VirtualCluster
+	protected VirtualCluster(IEnumerable<Node> nodes, MockProductRegistration productRegistration)
+	{
+		ProductRegistration = productRegistration;
+		InternalNodes = nodes.ToList();
+	}
+
+	public List<IClientCallRule> ClientCallRules { get; } = new List<IClientCallRule>();
+	public TestableDateTimeProvider DateTimeProvider { get; } = new TestableDateTimeProvider();
+
+	protected List<Node> InternalNodes { get; }
+	public IReadOnlyList<Node> Nodes => InternalNodes;
+	public List<IRule> PingingRules { get; } = new List<IRule>();
+
+	public List<ISniffRule> SniffingRules { get; } = new List<ISniffRule>();
+	internal string PublishAddressOverride { get; private set; }
+
+	internal bool SniffShouldReturnFqnd { get; private set; }
+	internal string ElasticsearchVersion { get; private set; } = "7.0.0";
+
+	public MockProductRegistration ProductRegistration { get; }
+
+	public VirtualCluster SniffShouldReturnFqdn()
+	{
+		SniffShouldReturnFqnd = true;
+		return this;
+	}
+
+	public VirtualCluster SniffElasticsearchVersionNumber(string version)
+	{
+		ElasticsearchVersion = version;
+		return this;
+	}
+
+	public VirtualCluster PublishAddress(string publishHost)
+	{
+		PublishAddressOverride = publishHost;
+		return this;
+	}
+
+	public VirtualCluster Ping(Func<PingRule, IRule> selector)
+	{
+		PingingRules.Add(selector(new PingRule()));
+		return this;
+	}
+
+	public VirtualCluster Sniff(Func<SniffRule, ISniffRule> selector)
+	{
+		SniffingRules.Add(selector(new SniffRule()));
+		return this;
+	}
+
+	public VirtualCluster ClientCalls(Func<ClientCallRule, IClientCallRule> selector)
+	{
+		ClientCallRules.Add(selector(new ClientCallRule()));
+		return this;
+	}
+
+	public SealedVirtualCluster SingleNodeConnection(Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null)
+	{
+		var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
+		return new SealedVirtualCluster(this, new SingleNodePool(nodes.First().Uri), DateTimeProvider, ProductRegistration);
+	}
+
+	public SealedVirtualCluster StaticNodePool(Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null)
+	{
+		var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
+		return new SealedVirtualCluster(this, new StaticNodePool(nodes, false, DateTimeProvider), DateTimeProvider, ProductRegistration);
+	}
+
+	public SealedVirtualCluster SniffingNodePool(Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null)
+	{
+		var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
+		return new SealedVirtualCluster(this, new SniffingNodePool(nodes, false, DateTimeProvider), DateTimeProvider, ProductRegistration);
+	}
+
+	public SealedVirtualCluster StickyNodePool(Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null)
+	{
+		var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
+		return new SealedVirtualCluster(this, new StickyNodePool(nodes, DateTimeProvider), DateTimeProvider, ProductRegistration);
+	}
+
+	public SealedVirtualCluster StickySniffingNodePool(Func<Node, float> sorter = null,
+		Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null
+	)
 	{
-		protected VirtualCluster(IEnumerable<Node> nodes, IMockProductRegistration productRegistration)
-		{
-			ProductRegistration = productRegistration;
-			InternalNodes = nodes.ToList();
-		}
-
-		public List<IClientCallRule> ClientCallRules { get; } = new List<IClientCallRule>();
-		public TestableDateTimeProvider DateTimeProvider { get; } = new TestableDateTimeProvider();
-
-		protected List<Node> InternalNodes { get; }
-		public IReadOnlyList<Node> Nodes => InternalNodes;
-		public List<IRule> PingingRules { get; } = new List<IRule>();
-
-		public List<ISniffRule> SniffingRules { get; } = new List<ISniffRule>();
-		internal string PublishAddressOverride { get; private set; }
-
-		internal bool SniffShouldReturnFqnd { get; private set; }
-		internal string ElasticsearchVersion { get; private set; } = "7.0.0";
-
-		public IMockProductRegistration ProductRegistration { get; }
-
-		public VirtualCluster SniffShouldReturnFqdn()
-		{
-			SniffShouldReturnFqnd = true;
-			return this;
-		}
-
-		public VirtualCluster SniffElasticsearchVersionNumber(string version)
-		{
-			ElasticsearchVersion = version;
-			return this;
-		}
-
-		public VirtualCluster PublishAddress(string publishHost)
-		{
-			PublishAddressOverride = publishHost;
-			return this;
-		}
-
-		public VirtualCluster Ping(Func<PingRule, IRule> selector)
-		{
-			PingingRules.Add(selector(new PingRule()));
-			return this;
-		}
-
-		public VirtualCluster Sniff(Func<SniffRule, ISniffRule> selector)
-		{
-			SniffingRules.Add(selector(new SniffRule()));
-			return this;
-		}
-
-		public VirtualCluster ClientCalls(Func<ClientCallRule, IClientCallRule> selector)
-		{
-			ClientCallRules.Add(selector(new ClientCallRule()));
-			return this;
-		}
-
-		public SealedVirtualCluster SingleNodeConnection(Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null)
-		{
-			var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
-			return new SealedVirtualCluster(this, new SingleNodePool(nodes.First().Uri), DateTimeProvider, ProductRegistration);
-		}
-
-		public SealedVirtualCluster StaticNodePool(Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null)
-		{
-			var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
-			return new SealedVirtualCluster(this, new StaticNodePool(nodes, false, DateTimeProvider), DateTimeProvider, ProductRegistration);
-		}
-
-		public SealedVirtualCluster SniffingNodePool(Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null)
-		{
-			var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
-			return new SealedVirtualCluster(this, new SniffingNodePool(nodes, false, DateTimeProvider), DateTimeProvider, ProductRegistration);
-		}
-
-		public SealedVirtualCluster StickyNodePool(Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null)
-		{
-			var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
-			return new SealedVirtualCluster(this, new StickyNodePool(nodes, DateTimeProvider), DateTimeProvider, ProductRegistration);
-		}
-
-		public SealedVirtualCluster StickySniffingNodePool(Func<Node, float> sorter = null,
-			Func<IList<Node>, IEnumerable<Node>> seedNodesSelector = null
-		)
-		{
-			var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
-			return new SealedVirtualCluster(this, new StickySniffingNodePool(nodes, sorter, DateTimeProvider), DateTimeProvider, ProductRegistration);
-		}
+		var nodes = seedNodesSelector?.Invoke(InternalNodes) ?? InternalNodes;
+		return new SealedVirtualCluster(this, new StickySniffingNodePool(nodes, sorter, DateTimeProvider), DateTimeProvider, ProductRegistration);
 	}
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Components/VirtualClusterConnection.cs b/src/Elastic.Transport.VirtualizedCluster/Components/VirtualClusterConnection.cs
index 2e4f664..26df108 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Components/VirtualClusterConnection.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Components/VirtualClusterConnection.cs
@@ -18,297 +18,296 @@
 using TheException = System.Net.WebException;
 #endif
 
-namespace Elastic.Transport.VirtualizedCluster.Components
+namespace Elastic.Transport.VirtualizedCluster.Components;
+
+/// <summary>
+/// An in memory connection that uses a rule engine to return different responses for sniffs/pings and API calls.
+/// <pre>
+/// Either instantiate through the static <see cref="Success"/> or <see cref="Error"/> for the simplest use-cases
+/// </pre>
+/// <pre>
+/// Or use <see cref="ElasticsearchVirtualCluster"/> to chain together a rule engine until
+/// <see cref="SealedVirtualCluster.VirtualClusterConnection"/> becomes available
+/// </pre>
+/// </summary>
+public class VirtualClusterConnection : InMemoryConnection
 {
-	/// <summary>
-	/// An in memory connection that uses a rule engine to return different responses for sniffs/pings and API calls.
-	/// <pre>
-	/// Either instantiate through the static <see cref="Success"/> or <see cref="Error"/> for the simplest use-cases
-	/// </pre>
-	/// <pre>
-	/// Or use <see cref="ElasticsearchVirtualCluster"/> to chain together a rule engine until
-	/// <see cref="SealedVirtualCluster.VirtualClusterConnection"/> becomes available
-	/// </pre>
-	/// </summary>
-	public class VirtualClusterConnection : InMemoryConnection
-	{
-		private static readonly object Lock = new object();
+	private static readonly object Lock = new();
 
-		private static byte[] _defaultResponseBytes;
+	private static byte[] _defaultResponseBytes;
 
-		private VirtualCluster _cluster;
-		private readonly TestableDateTimeProvider _dateTimeProvider;
-		private IMockProductRegistration _productRegistration;
-		private IDictionary<int, State> _calls = new Dictionary<int, State>();
+	private VirtualCluster _cluster;
+	private readonly TestableDateTimeProvider _dateTimeProvider;
+	private MockProductRegistration _productRegistration;
+	private IDictionary<int, State> _calls = new Dictionary<int, State>();
 
-		internal VirtualClusterConnection(VirtualCluster cluster, TestableDateTimeProvider dateTimeProvider)
-		{
-			UpdateCluster(cluster);
-			_dateTimeProvider = dateTimeProvider;
-			_productRegistration = cluster.ProductRegistration;
-		}
+	internal VirtualClusterConnection(VirtualCluster cluster, TestableDateTimeProvider dateTimeProvider)
+	{
+		UpdateCluster(cluster);
+		_dateTimeProvider = dateTimeProvider;
+		_productRegistration = cluster.ProductRegistration;
+	}
+
+	/// <summary>
+	/// Create a <see cref="VirtualClusterConnection"/> instance that always returns a successful response.
+	/// </summary>
+	/// <param name="response">The bytes to be returned on every API call invocation</param>
+	public static VirtualClusterConnection Success(byte[] response) =>
+		Virtual.Elasticsearch
+			.Bootstrap(1)
+			.ClientCalls(r => r.SucceedAlways().ReturnByteResponse(response))
+			.StaticNodePool()
+			.AllDefaults()
+			.Connection;
 
-		/// <summary>
-		/// Create a <see cref="VirtualClusterConnection"/> instance that always returns a successful response.
-		/// </summary>
-		/// <param name="response">The bytes to be returned on every API call invocation</param>
-		public static VirtualClusterConnection Success(byte[] response) =>
-			Virtual.Elasticsearch
-				.Bootstrap(1)
-				.ClientCalls(r => r.SucceedAlways().ReturnByteResponse(response))
-				.StaticNodePool()
-				.AllDefaults()
-				.Connection;
-
-		/// <summary>
-		/// Create a <see cref="VirtualClusterConnection"/> instance that always returns a failed response.
-		/// </summary>
-		public static VirtualClusterConnection Error() =>
-			Virtual.Elasticsearch
-				.Bootstrap(1)
-				.ClientCalls(r => r.FailAlways(400))
-				.StaticNodePool()
-				.AllDefaults()
-				.Connection;
-
-		private static object DefaultResponse
+	/// <summary>
+	/// Create a <see cref="VirtualClusterConnection"/> instance that always returns a failed response.
+	/// </summary>
+	public static VirtualClusterConnection Error() =>
+		Virtual.Elasticsearch
+			.Bootstrap(1)
+			.ClientCalls(r => r.FailAlways(400))
+			.StaticNodePool()
+			.AllDefaults()
+			.Connection;
+
+	private static object DefaultResponse
+	{
+		get
 		{
-			get
+			var response = new
 			{
-				var response = new
+				name = "Razor Fist",
+				cluster_name = "elasticsearch-test-cluster",
+				version = new
 				{
-					name = "Razor Fist",
-					cluster_name = "elasticsearch-test-cluster",
-					version = new
-					{
-						number = "2.0.0",
-						build_hash = "af1dc6d8099487755c3143c931665b709de3c764",
-						build_timestamp = "2015-07-07T11:28:47Z",
-						build_snapshot = true,
-						lucene_version = "5.2.1"
-					},
-					tagline = "You Know, for Search"
-				};
-				return response;
-			}
+					number = "2.0.0",
+					build_hash = "af1dc6d8099487755c3143c931665b709de3c764",
+					build_timestamp = "2015-07-07T11:28:47Z",
+					build_snapshot = true,
+					lucene_version = "5.2.1"
+				},
+				tagline = "You Know, for Search"
+			};
+			return response;
 		}
+	}
 
-		private void UpdateCluster(VirtualCluster cluster)
-		{
-			if (cluster == null) return;
+	private void UpdateCluster(VirtualCluster cluster)
+	{
+		if (cluster == null) return;
 
-			lock (Lock)
-			{
-				_cluster = cluster;
-				_calls = cluster.Nodes.ToDictionary(n => n.Uri.Port, v => new State());
-				_productRegistration = cluster.ProductRegistration;
-			}
+		lock (Lock)
+		{
+			_cluster = cluster;
+			_calls = cluster.Nodes.ToDictionary(n => n.Uri.Port, v => new State());
+			_productRegistration = cluster.ProductRegistration;
 		}
+	}
 
-		private bool IsSniffRequest(RequestData requestData) => _productRegistration.IsSniffRequest(requestData);
+	private bool IsSniffRequest(RequestData requestData) => _productRegistration.IsSniffRequest(requestData);
 
-		private bool IsPingRequest(RequestData requestData) => _productRegistration.IsPingRequest(requestData);
+	private bool IsPingRequest(RequestData requestData) => _productRegistration.IsPingRequest(requestData);
 
-		/// <inheritdoc cref="ITransportClient.RequestAsync{TResponse}"/>>
-		public override Task<TResponse> RequestAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken) =>
-			Task.FromResult(Request<TResponse>(requestData));
+	/// <inheritdoc cref="TransportClient.RequestAsync{TResponse}"/>>
+	public override Task<TResponse> RequestAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken) =>
+		Task.FromResult(Request<TResponse>(requestData));
 
-		/// <inheritdoc cref="ITransportClient.Request{TResponse}"/>>
-		public override TResponse Request<TResponse>(RequestData requestData)
-		{
-			if (!_calls.ContainsKey(requestData.Uri.Port))
-				throw new Exception($"Expected a call to happen on port {requestData.Uri.Port} but received none");
+	/// <inheritdoc cref="TransportClient.Request{TResponse}"/>>
+	public override TResponse Request<TResponse>(RequestData requestData)
+	{
+		if (!_calls.ContainsKey(requestData.Uri.Port))
+			throw new Exception($"Expected a call to happen on port {requestData.Uri.Port} but received none");
 
-			try
+		try
+		{
+			var state = _calls[requestData.Uri.Port];
+			if (IsSniffRequest(requestData))
 			{
-				var state = _calls[requestData.Uri.Port];
-				if (IsSniffRequest(requestData))
-				{
-					_ = Interlocked.Increment(ref state.Sniffed);
-					return HandleRules<TResponse, ISniffRule>(
-						requestData,
-						nameof(VirtualCluster.Sniff),
-						_cluster.SniffingRules,
-						requestData.RequestTimeout,
-						(r) => UpdateCluster(r.NewClusterState),
-						(r) => _productRegistration.CreateSniffResponseBytes(_cluster.Nodes, _cluster.ElasticsearchVersion,_cluster.PublishAddressOverride, _cluster.SniffShouldReturnFqnd)
-					);
-				}
-				if (IsPingRequest(requestData))
-				{
-					_ = Interlocked.Increment(ref state.Pinged);
-					return HandleRules<TResponse, IRule>(
-						requestData,
-						nameof(VirtualCluster.Ping),
-						_cluster.PingingRules,
-						requestData.PingTimeout,
-						(r) => { },
-						(r) => null //HEAD request
-					);
-				}
-				_ = Interlocked.Increment(ref state.Called);
-				return HandleRules<TResponse, IClientCallRule>(
+				_ = Interlocked.Increment(ref state.Sniffed);
+				return HandleRules<TResponse, ISniffRule>(
 					requestData,
-					nameof(VirtualCluster.ClientCalls),
-					_cluster.ClientCallRules,
+					nameof(VirtualCluster.Sniff),
+					_cluster.SniffingRules,
 					requestData.RequestTimeout,
-					(r) => { },
-					CallResponse
+					(r) => UpdateCluster(r.NewClusterState),
+					(r) => _productRegistration.CreateSniffResponseBytes(_cluster.Nodes, _cluster.ElasticsearchVersion, _cluster.PublishAddressOverride, _cluster.SniffShouldReturnFqnd)
 				);
 			}
-			catch (TheException e)
+			if (IsPingRequest(requestData))
 			{
-				return requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponse<TResponse>(requestData, e, null, null, Stream.Null, null, -1, null, null);
+				_ = Interlocked.Increment(ref state.Pinged);
+				return HandleRules<TResponse, IRule>(
+					requestData,
+					nameof(VirtualCluster.Ping),
+					_cluster.PingingRules,
+					requestData.PingTimeout,
+					(r) => { },
+					(r) => null //HEAD request
+				);
 			}
+			_ = Interlocked.Increment(ref state.Called);
+			return HandleRules<TResponse, IClientCallRule>(
+				requestData,
+				nameof(VirtualCluster.ClientCalls),
+				_cluster.ClientCallRules,
+				requestData.RequestTimeout,
+				(r) => { },
+				CallResponse
+			);
 		}
-
-		private TResponse HandleRules<TResponse, TRule>(
-			RequestData requestData,
-			string origin,
-			IList<TRule> rules,
-			TimeSpan timeout,
-			Action<TRule> beforeReturn,
-			Func<TRule, byte[]> successResponse
-		)
-			where TResponse : class, ITransportResponse, new()
-			where TRule : IRule
+		catch (TheException e)
 		{
-			requestData.MadeItToResponse = true;
-			if (rules.Count == 0)
-				throw new Exception($"No {origin} defined for the current VirtualCluster, so we do not know how to respond");
+			return requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponse<TResponse>(requestData, e, null, null, Stream.Null, null, -1, null, null);
+		}
+	}
 
-			foreach (var rule in rules.Where(s => s.OnPort.HasValue))
-			{
-				var always = rule.Times.Match(t => true, t => false);
-				var times = rule.Times.Match(t => -1, t => t);
+	private TResponse HandleRules<TResponse, TRule>(
+		RequestData requestData,
+		string origin,
+		IList<TRule> rules,
+		TimeSpan timeout,
+		Action<TRule> beforeReturn,
+		Func<TRule, byte[]> successResponse
+	)
+		where TResponse : TransportResponse, new()
+		where TRule : IRule
+	{
+		requestData.MadeItToResponse = true;
+		if (rules.Count == 0)
+			throw new Exception($"No {origin} defined for the current VirtualCluster, so we do not know how to respond");
 
-				if (rule.OnPort == null || rule.OnPort.Value != requestData.Uri.Port) continue;
+		foreach (var rule in rules.Where(s => s.OnPort.HasValue))
+		{
+			var always = rule.Times.Match(t => true, t => false);
+			var times = rule.Times.Match(t => -1, t => t);
 
-				if (always)
-					return Always<TResponse, TRule>(requestData, timeout, beforeReturn, successResponse, rule);
+			if (rule.OnPort == null || rule.OnPort.Value != requestData.Uri.Port) continue;
 
-				if (rule.ExecuteCount > times) continue;
+			if (always)
+				return Always<TResponse, TRule>(requestData, timeout, beforeReturn, successResponse, rule);
 
-				return Sometimes<TResponse, TRule>(requestData, timeout, beforeReturn, successResponse, rule);
-			}
-			foreach (var rule in rules.Where(s => !s.OnPort.HasValue))
-			{
-				var always = rule.Times.Match(t => true, t => false);
-				var times = rule.Times.Match(t => -1, t => t);
-				if (always)
-					return Always<TResponse, TRule>(requestData, timeout, beforeReturn, successResponse, rule);
+			if (rule.ExecuteCount > times) continue;
+
+			return Sometimes<TResponse, TRule>(requestData, timeout, beforeReturn, successResponse, rule);
+		}
+		foreach (var rule in rules.Where(s => !s.OnPort.HasValue))
+		{
+			var always = rule.Times.Match(t => true, t => false);
+			var times = rule.Times.Match(t => -1, t => t);
+			if (always)
+				return Always<TResponse, TRule>(requestData, timeout, beforeReturn, successResponse, rule);
 
-				if (rule.ExecuteCount > times) continue;
+			if (rule.ExecuteCount > times) continue;
 
-				return Sometimes<TResponse, TRule>(requestData, timeout, beforeReturn, successResponse, rule);
-			}
-			var count = _calls.Select(kv => kv.Value.Called).Sum();
-			throw new Exception($@"No global or port specific {origin} rule ({requestData.Uri.Port}) matches any longer after {count} calls in to the cluster");
+			return Sometimes<TResponse, TRule>(requestData, timeout, beforeReturn, successResponse, rule);
 		}
+		var count = _calls.Select(kv => kv.Value.Called).Sum();
+		throw new Exception($@"No global or port specific {origin} rule ({requestData.Uri.Port}) matches any longer after {count} calls in to the cluster");
+	}
 
-		private TResponse Always<TResponse, TRule>(RequestData requestData, TimeSpan timeout, Action<TRule> beforeReturn,
-			Func<TRule, byte[]> successResponse, TRule rule
-		)
-			where TResponse : class, ITransportResponse, new()
-			where TRule : IRule
+	private TResponse Always<TResponse, TRule>(RequestData requestData, TimeSpan timeout, Action<TRule> beforeReturn,
+		Func<TRule, byte[]> successResponse, TRule rule
+	)
+		where TResponse : TransportResponse, new()
+		where TRule : IRule
+	{
+		if (rule.Takes.HasValue)
 		{
-			if (rule.Takes.HasValue)
+			var time = timeout < rule.Takes.Value ? timeout : rule.Takes.Value;
+			_dateTimeProvider.ChangeTime(d => d.Add(time));
+			if (rule.Takes.Value > requestData.RequestTimeout)
 			{
-				var time = timeout < rule.Takes.Value ? timeout : rule.Takes.Value;
-				_dateTimeProvider.ChangeTime(d => d.Add(time));
-				if (rule.Takes.Value > requestData.RequestTimeout)
-				{
-					throw new TheException(
-						$"Request timed out after {time} : call configured to take {rule.Takes.Value} while requestTimeout was: {timeout}");
-				}
+				throw new TheException(
+					$"Request timed out after {time} : call configured to take {rule.Takes.Value} while requestTimeout was: {timeout}");
 			}
-
-			return rule.Succeeds
-				? Success<TResponse, TRule>(requestData, beforeReturn, successResponse, rule)
-				: Fail<TResponse, TRule>(requestData, rule);
 		}
 
-		private TResponse Sometimes<TResponse, TRule>(
-			RequestData requestData, TimeSpan timeout, Action<TRule> beforeReturn, Func<TRule, byte[]> successResponse, TRule rule
-		)
-			where TResponse : class, ITransportResponse, new()
-			where TRule : IRule
+		return rule.Succeeds
+			? Success<TResponse, TRule>(requestData, beforeReturn, successResponse, rule)
+			: Fail<TResponse, TRule>(requestData, rule);
+	}
+
+	private TResponse Sometimes<TResponse, TRule>(
+		RequestData requestData, TimeSpan timeout, Action<TRule> beforeReturn, Func<TRule, byte[]> successResponse, TRule rule
+	)
+		where TResponse : TransportResponse, new()
+		where TRule : IRule
+	{
+		if (rule.Takes.HasValue)
 		{
-			if (rule.Takes.HasValue)
+			var time = timeout < rule.Takes.Value ? timeout : rule.Takes.Value;
+			_dateTimeProvider.ChangeTime(d => d.Add(time));
+			if (rule.Takes.Value > requestData.RequestTimeout)
 			{
-				var time = timeout < rule.Takes.Value ? timeout : rule.Takes.Value;
-				_dateTimeProvider.ChangeTime(d => d.Add(time));
-				if (rule.Takes.Value > requestData.RequestTimeout)
-				{
-					throw new TheException(
-						$"Request timed out after {time} : call configured to take {rule.Takes.Value} while requestTimeout was: {timeout}");
-				}
+				throw new TheException(
+					$"Request timed out after {time} : call configured to take {rule.Takes.Value} while requestTimeout was: {timeout}");
 			}
-
-			if (rule.Succeeds)
-				return Success<TResponse, TRule>(requestData, beforeReturn, successResponse, rule);
-
-			return Fail<TResponse, TRule>(requestData, rule);
 		}
 
-		private TResponse Fail<TResponse, TRule>(RequestData requestData, TRule rule, RuleOption<Exception, int> returnOverride = null)
-			where TResponse : class, ITransportResponse, new()
-			where TRule : IRule
-		{
-			var state = _calls[requestData.Uri.Port];
-			_ = Interlocked.Increment(ref state.Failures);
-			var ret = returnOverride ?? rule.Return;
-			rule.RecordExecuted();
-
-			if (ret == null)
-				throw new TheException();
-
-			return ret.Match(
-				(e) => throw e,
-				(statusCode) => ReturnConnectionStatus<TResponse>(requestData, CallResponse(rule),
-					//make sure we never return a valid status code in Fail responses because of a bad rule.
-					statusCode >= 200 && statusCode < 300 ? 502 : statusCode, rule.ReturnContentType)
-			);
-		}
+		if (rule.Succeeds)
+			return Success<TResponse, TRule>(requestData, beforeReturn, successResponse, rule);
 
-		private TResponse Success<TResponse, TRule>(RequestData requestData, Action<TRule> beforeReturn, Func<TRule, byte[]> successResponse,
-			TRule rule
-		)
-			where TResponse : class, ITransportResponse, new()
-			where TRule : IRule
-		{
-			var state = _calls[requestData.Uri.Port];
-			_ = Interlocked.Increment(ref state.Successes);
-			rule.RecordExecuted();
+		return Fail<TResponse, TRule>(requestData, rule);
+	}
 
-			beforeReturn?.Invoke(rule);
-			return ReturnConnectionStatus<TResponse>(requestData, successResponse(rule), contentType: rule.ReturnContentType);
-		}
+	private TResponse Fail<TResponse, TRule>(RequestData requestData, TRule rule, RuleOption<Exception, int> returnOverride = null)
+		where TResponse : TransportResponse, new()
+		where TRule : IRule
+	{
+		var state = _calls[requestData.Uri.Port];
+		_ = Interlocked.Increment(ref state.Failures);
+		var ret = returnOverride ?? rule.Return;
+		rule.RecordExecuted();
+
+		if (ret == null)
+			throw new TheException();
+
+		return ret.Match(
+			(e) => throw e,
+			(statusCode) => ReturnConnectionStatus<TResponse>(requestData, CallResponse(rule),
+				//make sure we never return a valid status code in Fail responses because of a bad rule.
+				statusCode >= 200 && statusCode < 300 ? 502 : statusCode, rule.ReturnContentType)
+		);
+	}
 
-		private static byte[] CallResponse<TRule>(TRule rule)
-			where TRule : IRule
-		{
-			if (rule?.ReturnResponse != null)
-				return rule.ReturnResponse;
+	private TResponse Success<TResponse, TRule>(RequestData requestData, Action<TRule> beforeReturn, Func<TRule, byte[]> successResponse,
+		TRule rule
+	)
+		where TResponse : TransportResponse, new()
+		where TRule : IRule
+	{
+		var state = _calls[requestData.Uri.Port];
+		_ = Interlocked.Increment(ref state.Successes);
+		rule.RecordExecuted();
 
-			if (_defaultResponseBytes != null) return _defaultResponseBytes;
+		beforeReturn?.Invoke(rule);
+		return ReturnConnectionStatus<TResponse>(requestData, successResponse(rule), contentType: rule.ReturnContentType);
+	}
 
-			var response = DefaultResponse;
-			using (var ms = TransportConfiguration.DefaultMemoryStreamFactory.Create())
-			{
-				LowLevelRequestResponseSerializer.Instance.Serialize(response, ms);
-				_defaultResponseBytes = ms.ToArray();
-			}
-			return _defaultResponseBytes;
-		}
+	private static byte[] CallResponse<TRule>(TRule rule)
+		where TRule : IRule
+	{
+		if (rule?.ReturnResponse != null)
+			return rule.ReturnResponse;
 
-		private class State
+		if (_defaultResponseBytes != null) return _defaultResponseBytes;
+
+		var response = DefaultResponse;
+		using (var ms = TransportConfiguration.DefaultMemoryStreamFactory.Create())
 		{
-			public int Called;
-			public int Failures;
-			public int Pinged;
-			public int Sniffed;
-			public int Successes;
+			LowLevelRequestResponseSerializer.Instance.Serialize(response, ms);
+			_defaultResponseBytes = ms.ToArray();
 		}
+		return _defaultResponseBytes;
+	}
+
+	private class State
+	{
+		public int Called;
+		public int Failures;
+		public int Pinged;
+		public int Sniffed;
+		public int Successes;
 	}
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Components/VirtualizedCluster.cs b/src/Elastic.Transport.VirtualizedCluster/Components/VirtualizedCluster.cs
index 732d6ee..3314d90 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Components/VirtualizedCluster.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Components/VirtualizedCluster.cs
@@ -7,69 +7,68 @@
 using System.Threading.Tasks;
 using Elastic.Transport.VirtualizedCluster.Providers;
 
-namespace Elastic.Transport.VirtualizedCluster.Components
+namespace Elastic.Transport.VirtualizedCluster.Components;
+
+public class VirtualizedCluster
 {
-	public class VirtualizedCluster
-	{
-		private readonly ExposingPipelineFactory<TransportConfiguration> _exposingRequestPipeline;
-		private readonly TestableDateTimeProvider _dateTimeProvider;
-		private readonly TransportConfiguration _settings;
+	private readonly ExposingPipelineFactory<ITransportConfiguration> _exposingRequestPipeline;
+	private readonly TestableDateTimeProvider _dateTimeProvider;
+	private readonly TransportConfiguration _settings;
 
-		private Func<ITransport<ITransportConfiguration>, Func<RequestConfigurationDescriptor, IRequestConfiguration>, Task<ITransportResponse>> _asyncCall;
-		private Func<ITransport<ITransportConfiguration>, Func<RequestConfigurationDescriptor, IRequestConfiguration>, ITransportResponse> _syncCall;
+	private Func<HttpTransport<ITransportConfiguration>, Func<RequestConfigurationDescriptor, IRequestConfiguration>, Task<TransportResponse>> _asyncCall;
+	private Func<HttpTransport<ITransportConfiguration>, Func<RequestConfigurationDescriptor, IRequestConfiguration>, TransportResponse> _syncCall;
 
-		private class VirtualResponse : TransportResponse { }
+	private class VirtualResponse : TransportResponse { }
 
-		internal VirtualizedCluster(TestableDateTimeProvider dateTimeProvider, TransportConfiguration settings)
-		{
-			_dateTimeProvider = dateTimeProvider;
-			_settings = settings;
-			_exposingRequestPipeline = new ExposingPipelineFactory<TransportConfiguration>(settings, _dateTimeProvider);
+	internal VirtualizedCluster(TestableDateTimeProvider dateTimeProvider, TransportConfiguration settings)
+	{
+		_dateTimeProvider = dateTimeProvider;
+		_settings = settings;
+		_exposingRequestPipeline = new ExposingPipelineFactory<ITransportConfiguration>(settings, _dateTimeProvider);
 
-			_syncCall = (t, r) => t.Request<VirtualResponse>(
+		_syncCall = (t, r) => t.Request<VirtualResponse>(
+			HttpMethod.GET, "/",
+			PostData.Serializable(new {}), new DefaultRequestParameters()
+		{
+				RequestConfiguration = r?.Invoke(new RequestConfigurationDescriptor(null))
+		});
+		_asyncCall = async (t, r) =>
+		{
+			var res = await t.RequestAsync<VirtualResponse>
+			(
 				HttpMethod.GET, "/",
-				PostData.Serializable(new {}), new RequestParameters()
-			{
+				PostData.Serializable(new { }),
+				new DefaultRequestParameters()
+				{
 					RequestConfiguration = r?.Invoke(new RequestConfigurationDescriptor(null))
-			});
-			_asyncCall = async (t, r) =>
-			{
-				var res = await t.RequestAsync<VirtualResponse>
-				(
-					HttpMethod.GET, "/",
-					PostData.Serializable(new { }),
-					new RequestParameters()
-					{
-						RequestConfiguration = r?.Invoke(new RequestConfigurationDescriptor(null))
-					},
-					CancellationToken.None
-				).ConfigureAwait(false);
-				return (ITransportResponse)res;
-			};
-		}
+				},
+				CancellationToken.None
+			).ConfigureAwait(false);
+			return (TransportResponse)res;
+		};
+	}
 
-		public VirtualClusterConnection Connection => Transport.Settings.Connection as VirtualClusterConnection;
-		public NodePool ConnectionPool => Transport.Settings.NodePool;
-		public ITransport<ITransportConfiguration> Transport => _exposingRequestPipeline?.Transport;
+	public VirtualClusterConnection Connection => Transport.Settings.Connection as VirtualClusterConnection;
+	public NodePool ConnectionPool => Transport.Settings.NodePool;
+	public HttpTransport<ITransportConfiguration> Transport => _exposingRequestPipeline?.Transport;
 
-		public VirtualizedCluster TransportProxiesTo(
-			Func<ITransport<ITransportConfiguration>, Func<RequestConfigurationDescriptor, IRequestConfiguration>, ITransportResponse> sync,
-			Func<ITransport<ITransportConfiguration>, Func<RequestConfigurationDescriptor, IRequestConfiguration>, Task<ITransportResponse>> async
-		)
-		{
-			_syncCall = sync;
-			_asyncCall = async;
-			return this;
-		}
+	public VirtualizedCluster TransportProxiesTo(
+		Func<HttpTransport<ITransportConfiguration>, Func<RequestConfigurationDescriptor, IRequestConfiguration>, TransportResponse> sync,
+		Func<HttpTransport<ITransportConfiguration>, Func<RequestConfigurationDescriptor, IRequestConfiguration>, Task<TransportResponse>> async
+	)
+	{
+		_syncCall = sync;
+		_asyncCall = async;
+		return this;
+	}
 
-		public ITransportResponse ClientCall(Func<RequestConfigurationDescriptor, IRequestConfiguration> requestOverrides = null) =>
-			_syncCall(Transport, requestOverrides);
+	public TransportResponse ClientCall(Func<RequestConfigurationDescriptor, IRequestConfiguration> requestOverrides = null) =>
+		_syncCall(Transport, requestOverrides);
 
-		public async Task<ITransportResponse> ClientCallAsync(Func<RequestConfigurationDescriptor, IRequestConfiguration> requestOverrides = null) =>
-			await _asyncCall(Transport, requestOverrides).ConfigureAwait(false);
+	public async Task<TransportResponse> ClientCallAsync(Func<RequestConfigurationDescriptor, IRequestConfiguration> requestOverrides = null) =>
+		await _asyncCall(Transport, requestOverrides).ConfigureAwait(false);
 
-		public void ChangeTime(Func<DateTime, DateTime> change) => _dateTimeProvider.ChangeTime(change);
+	public void ChangeTime(Func<DateTime, DateTime> change) => _dateTimeProvider.ChangeTime(change);
 
-		public void ClientThrows(bool throws) => _settings.ThrowExceptions(throws);
-	}
+	public void ClientThrows(bool throws) => _settings.ThrowExceptions(throws);
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Elastic.Transport.VirtualizedCluster.csproj b/src/Elastic.Transport.VirtualizedCluster/Elastic.Transport.VirtualizedCluster.csproj
index 3722344..152a940 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Elastic.Transport.VirtualizedCluster.csproj
+++ b/src/Elastic.Transport.VirtualizedCluster/Elastic.Transport.VirtualizedCluster.csproj
@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <PackageId>Elastic.Transport.VirtualizedCluster</PackageId>
-    <Title>Elastic.Transport.VirtualizedCluster - An in memory ITransportClient that can simulate large cluster</Title>
+    <Title>Elastic.Transport.VirtualizedCluster - An in memory TransportClient that can simulate large cluster</Title>
     <PackageTags>elasticsearch;elastic;search;lucene;nest</PackageTags>
     <Description>Provides a way to assert transport behaviour through a rule engine backed VirtualClusterConnection</Description>
     <NoWarn>CS1591;$(NoWarn);IDT001</NoWarn>
diff --git a/src/Elastic.Transport.VirtualizedCluster/Extensions/NumericExtensions.cs b/src/Elastic.Transport.VirtualizedCluster/Extensions/NumericExtensions.cs
index 7747410..dab3f5d 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Extensions/NumericExtensions.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Extensions/NumericExtensions.cs
@@ -2,8 +2,8 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport.VirtualizedCluster.Extensions
-{
+namespace Elastic.Transport.VirtualizedCluster.Extensions;
+
 	internal static class NumericExtensions
 	{
 		public static string ToOrdinal(this int num)
@@ -31,4 +31,3 @@ public static string ToOrdinal(this int num)
 			}
 		}
 	}
-}
diff --git a/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchMockProductRegistration.cs b/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchMockProductRegistration.cs
index 9082509..5f3c3f5 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchMockProductRegistration.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchMockProductRegistration.cs
@@ -7,26 +7,25 @@
 using Elastic.Transport.Products;
 using Elastic.Transport.Products.Elasticsearch;
 
-namespace Elastic.Transport.VirtualizedCluster.Products.Elasticsearch
+namespace Elastic.Transport.VirtualizedCluster.Products.Elasticsearch;
+
+/// <inheritdoc cref="MockProductRegistration"/>>
+public sealed class ElasticsearchMockProductRegistration : MockProductRegistration
 {
-	/// <inheritdoc cref="IMockProductRegistration"/>>
-	public class ElasticsearchMockProductRegistration : IMockProductRegistration
-	{
-		/// <summary> A static instance of <see cref="ElasticsearchMockProductRegistration"/> to reuse </summary>
-		public static IMockProductRegistration Default { get; } = new ElasticsearchMockProductRegistration();
+	/// <summary> A static instance of <see cref="ElasticsearchMockProductRegistration"/> to reuse </summary>
+	public static MockProductRegistration Default { get; } = new ElasticsearchMockProductRegistration();
 
-		/// <inheritdoc cref="IMockProductRegistration.ProductRegistration"/>>
-		public IProductRegistration ProductRegistration { get; } = ElasticsearchProductRegistration.Default;
+	/// <inheritdoc cref="MockProductRegistration.ProductRegistration"/>>
+	public override ProductRegistration ProductRegistration { get; } = ElasticsearchProductRegistration.Default;
 
-		/// <inheritdoc cref="IMockProductRegistration.CreateSniffResponseBytes"/>>
-		public byte[] CreateSniffResponseBytes(IReadOnlyList<Node> nodes, string stackVersion, string publishAddressOverride, bool returnFullyQualifiedDomainNames) =>
-			ElasticsearchSniffResponseFactory.Create(nodes, stackVersion, publishAddressOverride, returnFullyQualifiedDomainNames);
+	/// <inheritdoc cref="MockProductRegistration.CreateSniffResponseBytes"/>>
+	public override byte[] CreateSniffResponseBytes(IReadOnlyList<Node> nodes, string stackVersion, string publishAddressOverride, bool returnFullyQualifiedDomainNames) =>
+		ElasticsearchSniffResponseFactory.Create(nodes, stackVersion, publishAddressOverride, returnFullyQualifiedDomainNames);
 
-		public bool IsSniffRequest(RequestData requestData) =>
-			requestData.PathAndQuery.StartsWith(ElasticsearchProductRegistration.SniffPath, StringComparison.Ordinal);
+	public override bool IsSniffRequest(RequestData requestData) =>
+		requestData.PathAndQuery.StartsWith(ElasticsearchProductRegistration.SniffPath, StringComparison.Ordinal);
 
-		public bool IsPingRequest(RequestData requestData) =>
-			requestData.Method == HttpMethod.HEAD &&
-			(requestData.PathAndQuery == string.Empty || requestData.PathAndQuery.StartsWith("?"));
-	}
+	public override bool IsPingRequest(RequestData requestData) =>
+		requestData.Method == HttpMethod.HEAD &&
+		(requestData.PathAndQuery == string.Empty || requestData.PathAndQuery.StartsWith("?"));
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchSniffResponseFactory.cs b/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchSniffResponseFactory.cs
index 3fa941a..cb46dea 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchSniffResponseFactory.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchSniffResponseFactory.cs
@@ -7,83 +7,82 @@
 using System.Linq;
 using Elastic.Transport.Products.Elasticsearch;
 
-namespace Elastic.Transport.VirtualizedCluster.Products.Elasticsearch
+namespace Elastic.Transport.VirtualizedCluster.Products.Elasticsearch;
+
+/// <summary> A static util method to create an Elasticsearch sniff response. </summary>
+public static class ElasticsearchSniffResponseFactory
 {
-	/// <summary> A static util method to create an Elasticsearch sniff response. </summary>
-	public static class ElasticsearchSniffResponseFactory
-	{
-		private static string ClusterName => "elasticsearch-test-cluster";
+	private static string ClusterName => "elasticsearch-test-cluster";
 
-		/// <inheritdoc cref="IMockProductRegistration.CreateSniffResponseBytes"/>>
-		public static byte[] Create(IEnumerable<Node> nodes, string elasticsearchVersion,string publishAddressOverride, bool randomFqdn = false)
+	/// <inheritdoc cref="MockProductRegistration.CreateSniffResponseBytes"/>>
+	public static byte[] Create(IEnumerable<Node> nodes, string elasticsearchVersion, string publishAddressOverride, bool randomFqdn = false)
+	{
+		var response = new
 		{
-			var response = new
-			{
-				cluster_name = ClusterName,
-				nodes = SniffResponseNodes(nodes, elasticsearchVersion, publishAddressOverride, randomFqdn)
-			};
-			using (var ms = TransportConfiguration.DefaultMemoryStreamFactory.Create())
-			{
-				LowLevelRequestResponseSerializer.Instance.Serialize(response, ms);
-				return ms.ToArray();
-			}
+			cluster_name = ClusterName,
+			nodes = SniffResponseNodes(nodes, elasticsearchVersion, publishAddressOverride, randomFqdn)
+		};
+		using (var ms = TransportConfiguration.DefaultMemoryStreamFactory.Create())
+		{
+			LowLevelRequestResponseSerializer.Instance.Serialize(response, ms);
+			return ms.ToArray();
 		}
+	}
 
-		private static IDictionary<string, object> SniffResponseNodes(
-			IEnumerable<Node> nodes,
-			string elasticsearchVersion,
-			string publishAddressOverride,
-			bool randomFqdn
-		) =>
-			(from node in nodes
-				let id = string.IsNullOrEmpty(node.Id) ? Guid.NewGuid().ToString("N").Substring(0, 8) : node.Id
-				let name = string.IsNullOrEmpty(node.Name) ? Guid.NewGuid().ToString("N").Substring(0, 8) : node.Name
-				select new { id, name, node })
-			.ToDictionary(kv => kv.id, kv => CreateNodeResponse(kv.node, kv.name, elasticsearchVersion, publishAddressOverride, randomFqdn));
+	private static IDictionary<string, object> SniffResponseNodes(
+		IEnumerable<Node> nodes,
+		string elasticsearchVersion,
+		string publishAddressOverride,
+		bool randomFqdn
+	) =>
+		(from node in nodes
+		 let id = string.IsNullOrEmpty(node.Id) ? Guid.NewGuid().ToString("N").Substring(0, 8) : node.Id
+		 let name = string.IsNullOrEmpty(node.Name) ? Guid.NewGuid().ToString("N").Substring(0, 8) : node.Name
+		 select new { id, name, node })
+		.ToDictionary(kv => kv.id, kv => CreateNodeResponse(kv.node, kv.name, elasticsearchVersion, publishAddressOverride, randomFqdn));
 
-		private static object CreateNodeResponse(Node node, string name, string elasticsearchVersion, string publishAddressOverride, bool randomFqdn)
-		{
-			var port = node.Uri.Port;
-			var fqdn = randomFqdn ? $"fqdn{port}/" : "";
-			var host = !string.IsNullOrWhiteSpace(publishAddressOverride) ? publishAddressOverride : "127.0.0.1";
+	private static object CreateNodeResponse(Node node, string name, string elasticsearchVersion, string publishAddressOverride, bool randomFqdn)
+	{
+		var port = node.Uri.Port;
+		var fqdn = randomFqdn ? $"fqdn{port}/" : "";
+		var host = !string.IsNullOrWhiteSpace(publishAddressOverride) ? publishAddressOverride : "127.0.0.1";
 
-			var settings = new Dictionary<string, object>
+		var settings = new Dictionary<string, object>
 			{
 				{ "cluster.name", ClusterName },
 				{ "node.name", name }
 			};
-			foreach (var kv in node.Settings) settings[kv.Key] = kv.Value;
+		foreach (var kv in node.Settings) settings[kv.Key] = kv.Value;
 
-			var httpEnabled = node.HasFeature(ElasticsearchNodeFeatures.HttpEnabled);
+		var httpEnabled = node.HasFeature(ElasticsearchNodeFeatures.HttpEnabled);
 
-			var nodeResponse = new
-			{
-				name,
-				settings,
-				transport_address = $"127.0.0.1:{port + 1000}]",
-				host = Guid.NewGuid().ToString("N").Substring(0, 8),
-				ip = "127.0.0.1",
-				version = elasticsearchVersion,
-				build_hash = Guid.NewGuid().ToString("N").Substring(0, 8),
-				roles = new List<string>(),
-				http = httpEnabled
-					? new
+		var nodeResponse = new
+		{
+			name,
+			settings,
+			transport_address = $"127.0.0.1:{port + 1000}]",
+			host = Guid.NewGuid().ToString("N").Substring(0, 8),
+			ip = "127.0.0.1",
+			version = elasticsearchVersion,
+			build_hash = Guid.NewGuid().ToString("N").Substring(0, 8),
+			roles = new List<string>(),
+			http = httpEnabled
+				? new
+				{
+					bound_address = new[]
 					{
-						bound_address = new[]
-						{
 							$"{fqdn}127.0.0.1:{port}"
-						},
-						//publish_address = $"{fqdn}${publishAddress}"
-						publish_address = $"{fqdn}{host}:{port}"
-					}
-					: null
-			};
-			if (node.HasFeature(ElasticsearchNodeFeatures.MasterEligible)) nodeResponse.roles.Add("master");
-			if (node.HasFeature(ElasticsearchNodeFeatures.HoldsData)) nodeResponse.roles.Add("data");
-			if (node.HasFeature(ElasticsearchNodeFeatures.IngestEnabled)) nodeResponse.roles.Add("ingest");
-			if (!httpEnabled)
-				nodeResponse.settings.Add("http.enabled", false);
-			return nodeResponse;
-		}
+					},
+					//publish_address = $"{fqdn}${publishAddress}"
+					publish_address = $"{fqdn}{host}:{port}"
+				}
+				: null
+		};
+		if (node.HasFeature(ElasticsearchNodeFeatures.MasterEligible)) nodeResponse.roles.Add("master");
+		if (node.HasFeature(ElasticsearchNodeFeatures.HoldsData)) nodeResponse.roles.Add("data");
+		if (node.HasFeature(ElasticsearchNodeFeatures.IngestEnabled)) nodeResponse.roles.Add("ingest");
+		if (!httpEnabled)
+			nodeResponse.settings.Add("http.enabled", false);
+		return nodeResponse;
 	}
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchVirtualCluster.cs b/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchVirtualCluster.cs
index b89db53..021c060 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchVirtualCluster.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Products/Elasticsearch/ElasticsearchVirtualCluster.cs
@@ -9,98 +9,95 @@
 using Elastic.Transport.Products.Elasticsearch;
 using Elastic.Transport.VirtualizedCluster.Components;
 
-namespace Elastic.Transport.VirtualizedCluster.Products.Elasticsearch
+namespace Elastic.Transport.VirtualizedCluster.Products.Elasticsearch;
+
+/// <summary>
+/// Bootstrap an elasticsearch virtual cluster. This class can not be instantiated directly, use <see cref="Virtual.Elasticsearch" /> instead.
+/// </summary>
+public sealed class ElasticsearchClusterFactory
 {
+	internal static ElasticsearchClusterFactory Default { get; } = new ElasticsearchClusterFactory();
+
+	private ElasticsearchClusterFactory() { }
+
+	// ReSharper disable once MemberCanBeMadeStatic.Global
 	/// <summary>
-	/// Bootstrap an elasticsearch virtual cluster. This class can not be instantiated directly, use <see cref="Virtual.Elasticsearch" /> instead.
+	/// Bootstrap a cluster with <paramref name="numberOfNodes"/>. By default all clusters start their nodes at 9200.
+	/// <para>You can provide a different starting number using <paramref name="startFrom"/>.</para>
 	/// </summary>
-	public class ElasticsearchClusterFactory
-	{
-		internal static ElasticsearchClusterFactory Default { get; } = new ElasticsearchClusterFactory();
-
-		private ElasticsearchClusterFactory() { }
+	public ElasticsearchVirtualCluster Bootstrap(int numberOfNodes, int startFrom = 9200) =>
+		new(
+			Enumerable.Range(startFrom, numberOfNodes).Select(n => new Node(new Uri($"http://localhost:{n}")))
+		);
 
-		// ReSharper disable once MemberCanBeMadeStatic.Global
-		/// <summary>
-		/// Bootstrap a cluster with <paramref name="numberOfNodes"/>. By default all clusters start their nodes at 9200.
-		/// <para>You can provide a different starting number using <paramref name="startFrom"/>.</para>
-		/// </summary>
-		public ElasticsearchVirtualCluster Bootstrap(int numberOfNodes, int startFrom = 9200) =>
-			new ElasticsearchVirtualCluster(
-				Enumerable.Range(startFrom, numberOfNodes).Select(n => new Node(new Uri($"http://localhost:{n}")))
-			);
+	// ReSharper disable once MemberCanBeMadeStatic.Global
+	/// <summary> Bootstrap a cluster by providing the nodes explicitly </summary>
+	public ElasticsearchVirtualCluster Bootstrap(IEnumerable<Node> nodes) => new(nodes);
 
-		// ReSharper disable once MemberCanBeMadeStatic.Global
-		/// <summary> Bootstrap a cluster by providing the nodes explicitly </summary>
-		public ElasticsearchVirtualCluster Bootstrap(IEnumerable<Node> nodes) => new ElasticsearchVirtualCluster(nodes);
+	// ReSharper disable once MemberCanBeMadeStatic.Global
+	/// <summary>
+	/// Bootstrap a cluster with <paramref name="numberOfNodes"/>. By default all clusters start their nodes at 9200.
+	/// <para>You can provide a different starting number using <paramref name="startFrom"/>.</para>
+	/// <para>Using this overload all the nodes in the cluster are ONLY master eligible</para>
+	/// </summary>
+	public ElasticsearchVirtualCluster BootstrapAllMasterEligableOnly(int numberOfNodes, int startFrom = 9200) =>
+		new(
+			Enumerable.Range(startFrom, numberOfNodes)
+				.Select(n => new Node(new Uri($"http://localhost:{n}"), ElasticsearchNodeFeatures.MasterEligibleOnly)
+				)
+		);
+}
 
-		// ReSharper disable once MemberCanBeMadeStatic.Global
-		/// <summary>
-		/// Bootstrap a cluster with <paramref name="numberOfNodes"/>. By default all clusters start their nodes at 9200.
-		/// <para>You can provide a different starting number using <paramref name="startFrom"/>.</para>
-		/// <para>Using this overload all the nodes in the cluster are ONLY master eligible</para>
-		/// </summary>
-		public ElasticsearchVirtualCluster BootstrapAllMasterEligableOnly(int numberOfNodes, int startFrom = 9200) =>
-			new ElasticsearchVirtualCluster(
-				Enumerable.Range(startFrom, numberOfNodes)
-					.Select(n => new Node(new Uri($"http://localhost:{n}"), ElasticsearchNodeFeatures.MasterEligibleOnly)
-					)
-			);
-	}
+/// <summary>
+/// Create a virtual Elasticsearch cluster by passing a list of <see cref="Node"/>.
+/// <para>Please see <see cref="Virtual.Elasticsearch" /> for a more convenient pattern to create an instance of this class.</para>
+/// </summary>
+public class ElasticsearchVirtualCluster : VirtualCluster
+{
+	/// <inheritdoc cref="ElasticsearchVirtualCluster"/>>
+	public ElasticsearchVirtualCluster(IEnumerable<Node> nodes) : base(nodes, ElasticsearchMockProductRegistration.Default) { }
 
 	/// <summary>
-	/// Create a virtual Elasticsearch cluster by passing a list of <see cref="Node"/>.
-	/// <para>Please see <see cref="Virtual.Elasticsearch" /> for a more convenient pattern to create an instance of this class.</para>
+	/// Makes sure **only** the nodes with the passed port numbers are marked as master eligible. By default **all** nodes
+	/// are master eligible.
 	/// </summary>
-	public class ElasticsearchVirtualCluster : VirtualCluster
+	public ElasticsearchVirtualCluster MasterEligible(params int[] ports)
 	{
-		/// <inheritdoc cref="ElasticsearchVirtualCluster"/>>
-		public ElasticsearchVirtualCluster(IEnumerable<Node> nodes) : base(nodes, ElasticsearchMockProductRegistration.Default) { }
-
-		/// <summary>
-		/// Makes sure **only** the nodes with the passed port numbers are marked as master eligible. By default **all** nodes
-		/// are master eligible.
-		/// </summary>
-		public ElasticsearchVirtualCluster MasterEligible(params int[] ports)
+		foreach (var node in InternalNodes.Where(n => !ports.Contains(n.Uri.Port)))
 		{
-			foreach (var node in InternalNodes.Where(n => !ports.Contains(n.Uri.Port)))
-			{
-				var currentFeatures = node.Features.Count == 0 ? ElasticsearchNodeFeatures.Default : node.Features;
-				node.Features = currentFeatures.Except(new[] { ElasticsearchNodeFeatures.MasterEligible }).ToList().AsReadOnly();
-			}
-			return this;
-		}
-
-		/// <summary> Removes the data role from the nodes with the passed port numbers </summary>
-		public ElasticsearchVirtualCluster StoresNoData(params int[] ports)
-		{
-			foreach (var node in InternalNodes.Where(n => ports.Contains(n.Uri.Port)))
-			{
-				var currentFeatures = node.Features.Count == 0 ? ElasticsearchNodeFeatures.Default : node.Features;
-				node.Features = currentFeatures.Except(new[] { ElasticsearchNodeFeatures.HoldsData }).ToList().AsReadOnly();
-			}
-			return this;
+			var currentFeatures = node.Features.Count == 0 ? ElasticsearchNodeFeatures.Default : node.Features;
+			node.Features = currentFeatures.Except(new[] { ElasticsearchNodeFeatures.MasterEligible }).ToList().AsReadOnly();
 		}
+		return this;
+	}
 
-		/// <summary> Disables http on the nodes with the passed port numbers </summary>
-		public VirtualCluster HttpDisabled(params int[] ports)
+	/// <summary> Removes the data role from the nodes with the passed port numbers </summary>
+	public ElasticsearchVirtualCluster StoresNoData(params int[] ports)
+	{
+		foreach (var node in InternalNodes.Where(n => ports.Contains(n.Uri.Port)))
 		{
-			foreach (var node in InternalNodes.Where(n => ports.Contains(n.Uri.Port)))
-			{
-				var currentFeatures = node.Features.Count == 0 ? ElasticsearchNodeFeatures.Default : node.Features;
-				node.Features = currentFeatures.Except(new[] { ElasticsearchNodeFeatures.HttpEnabled }).ToList().AsReadOnly();
-			}
-			return this;
+			var currentFeatures = node.Features.Count == 0 ? ElasticsearchNodeFeatures.Default : node.Features;
+			node.Features = currentFeatures.Except(new[] { ElasticsearchNodeFeatures.HoldsData }).ToList().AsReadOnly();
 		}
+		return this;
+	}
 
-		/// <summary> Add a setting to the nodes with the passed port numbers </summary>
-		public ElasticsearchVirtualCluster HasSetting(string key, string value, params int[] ports)
+	/// <summary> Disables http on the nodes with the passed port numbers </summary>
+	public VirtualCluster HttpDisabled(params int[] ports)
+	{
+		foreach (var node in InternalNodes.Where(n => ports.Contains(n.Uri.Port)))
 		{
-			foreach (var node in InternalNodes.Where(n => ports.Contains(n.Uri.Port)))
-				node.Settings = new ReadOnlyDictionary<string, object>(new Dictionary<string, object> { { key, value } });
-			return this;
+			var currentFeatures = node.Features.Count == 0 ? ElasticsearchNodeFeatures.Default : node.Features;
+			node.Features = currentFeatures.Except(new[] { ElasticsearchNodeFeatures.HttpEnabled }).ToList().AsReadOnly();
 		}
+		return this;
+	}
 
-
+	/// <summary> Add a setting to the nodes with the passed port numbers </summary>
+	public ElasticsearchVirtualCluster HasSetting(string key, string value, params int[] ports)
+	{
+		foreach (var node in InternalNodes.Where(n => ports.Contains(n.Uri.Port)))
+			node.Settings = new ReadOnlyDictionary<string, object>(new Dictionary<string, object> { { key, value } });
+		return this;
 	}
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Products/IMockProductRegistration.cs b/src/Elastic.Transport.VirtualizedCluster/Products/IMockProductRegistration.cs
deleted file mode 100644
index 4347ccc..0000000
--- a/src/Elastic.Transport.VirtualizedCluster/Products/IMockProductRegistration.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System.Collections.Generic;
-using Elastic.Transport.Products;
-using Elastic.Transport.VirtualizedCluster.Components;
-
-namespace Elastic.Transport.VirtualizedCluster.Products
-{
-	/// <summary>
-	/// Makes sure <see cref="VirtualClusterConnection"/> is mockable by providing a different sniff response based on the current <see cref="ProductRegistration"/>
-	/// </summary>
-	public interface IMockProductRegistration
-	{
-		/// <summary>
-		/// Information about the current product we are injecting into <see cref="Transport{TConnectionSettings}"/>
-		/// </summary>
-		IProductRegistration ProductRegistration { get; }
-
-		/// <summary>
-		/// Return the sniff response for the product as raw bytes for <see cref="ITransportClient.Request{TResponse}"/> to return.
-		/// </summary>
-		/// <param name="nodes">The nodes we expect to be returned in the response</param>
-		/// <param name="stackVersion">The current version under test</param>
-		/// <param name="publishAddressOverride">Return this hostname instead of some IP</param>
-		/// <param name="returnFullyQualifiedDomainNames">If the sniff can return internal + external information return both</param>
-		byte[] CreateSniffResponseBytes(IReadOnlyList<Node> nodes, string stackVersion, string publishAddressOverride, bool returnFullyQualifiedDomainNames);
-
-		/// <summary>
-		/// see <see cref="VirtualClusterConnection.Request{TResponse}"/> uses this to determine if the current request is a sniff request and should follow
-		/// the sniffing rules
-		/// </summary>
-		bool IsSniffRequest(RequestData requestData);
-
-		bool IsPingRequest(RequestData requestData);
-	}
-}
diff --git a/src/Elastic.Transport.VirtualizedCluster/Products/MockProductRegistration.cs b/src/Elastic.Transport.VirtualizedCluster/Products/MockProductRegistration.cs
new file mode 100644
index 0000000..f54647c
--- /dev/null
+++ b/src/Elastic.Transport.VirtualizedCluster/Products/MockProductRegistration.cs
@@ -0,0 +1,37 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System.Collections.Generic;
+using Elastic.Transport.Products;
+using Elastic.Transport.VirtualizedCluster.Components;
+
+namespace Elastic.Transport.VirtualizedCluster.Products;
+
+/// <summary>
+/// Makes sure <see cref="VirtualClusterConnection"/> is mockable by providing a different sniff response based on the current <see cref="ProductRegistration"/>
+/// </summary>
+public abstract class MockProductRegistration
+{
+	/// <summary>
+	/// Information about the current product we are injecting into <see cref="HttpTransport{TConnectionSettings}"/>
+	/// </summary>
+	public abstract ProductRegistration ProductRegistration { get; }
+
+	/// <summary>
+	/// Return the sniff response for the product as raw bytes for <see cref="TransportClient.Request{TResponse}"/> to return.
+	/// </summary>
+	/// <param name="nodes">The nodes we expect to be returned in the response</param>
+	/// <param name="stackVersion">The current version under test</param>
+	/// <param name="publishAddressOverride">Return this hostname instead of some IP</param>
+	/// <param name="returnFullyQualifiedDomainNames">If the sniff can return internal + external information return both</param>
+	public abstract byte[] CreateSniffResponseBytes(IReadOnlyList<Node> nodes, string stackVersion, string publishAddressOverride, bool returnFullyQualifiedDomainNames);
+
+	/// <summary>
+	/// see <see cref="VirtualClusterConnection.Request{TResponse}"/> uses this to determine if the current request is a sniff request and should follow
+	/// the sniffing rules
+	/// </summary>
+	public abstract bool IsSniffRequest(RequestData requestData);
+
+	public abstract bool IsPingRequest(RequestData requestData);
+}
diff --git a/src/Elastic.Transport.VirtualizedCluster/Providers/TestableDateTimeProvider.cs b/src/Elastic.Transport.VirtualizedCluster/Providers/TestableDateTimeProvider.cs
index 762704c..054f5fb 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Providers/TestableDateTimeProvider.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Providers/TestableDateTimeProvider.cs
@@ -4,20 +4,21 @@
 
 using System;
 
-namespace Elastic.Transport.VirtualizedCluster.Providers
+namespace Elastic.Transport.VirtualizedCluster.Providers;
+
+/// <inheritdoc cref="DateTimeProvider"/>
+public sealed class TestableDateTimeProvider : DateTimeProvider
 {
-	/// <inheritdoc cref="IDateTimeProvider"/>
-	public class TestableDateTimeProvider : DateTimeProvider
-	{
-		private DateTime MutableNow { get; set; } = DateTime.UtcNow;
+	private DateTime MutableNow { get; set; } = DateTime.UtcNow;
+
+	/// <inheritdoc cref="DateTimeProvider.Now"/>
+	public override DateTime Now() => MutableNow;
 
-		/// <inheritdoc cref="IDateTimeProvider.Now"/>
-		public override DateTime Now() => MutableNow;
+	/// <summary>
+	/// Advance the time <see cref="Now"/> returns
+	/// </summary>
+	/// <param name="change">A fun that gets passed the current <see cref="Now"/> and needs to return the new value</param>
+	public void ChangeTime(Func<DateTime, DateTime> change) => MutableNow = change(MutableNow);
 
-		/// <summary>
-		/// Advance the time <see cref="Now"/> returns
-		/// </summary>
-		/// <param name="change">A fun that gets passed the current <see cref="Now"/> and needs to return the new value</param>
-		public void ChangeTime(Func<DateTime, DateTime> change) => MutableNow = change(MutableNow);
-	}
+	public override DateTime DeadTime(int attempts, TimeSpan? minDeadTimeout, TimeSpan? maxDeadTimeout) => throw new NotImplementedException();
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Rules/ClientCallRule.cs b/src/Elastic.Transport.VirtualizedCluster/Rules/ClientCallRule.cs
index f6c9dad..820f79f 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Rules/ClientCallRule.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Rules/ClientCallRule.cs
@@ -2,51 +2,50 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-using System;
 #if DOTNETCORE
+using System;
 using TheException = System.Net.Http.HttpRequestException;
 #else
 using TheException = System.Net.WebException;
 #endif
 
-namespace Elastic.Transport.VirtualizedCluster.Rules
+namespace Elastic.Transport.VirtualizedCluster.Rules;
+
+public interface IClientCallRule : IRule { }
+
+public sealed class ClientCallRule : RuleBase<ClientCallRule>, IClientCallRule
 {
-	public interface IClientCallRule : IRule { }
+	private IClientCallRule Self => this;
 
-	public class ClientCallRule : RuleBase<ClientCallRule>, IClientCallRule
+	public ClientCallRule Fails(RuleOption<TimesHelper.AllTimes, int> times, RuleOption<Exception, int> errorState = null)
 	{
-		private IClientCallRule Self => this;
-
-		public ClientCallRule Fails(RuleOption<TimesHelper.AllTimes, int> times, RuleOption<Exception, int> errorState = null)
-		{
-			Self.Times = times;
-			Self.Succeeds = false;
-			Self.Return = errorState ?? new TheException();
-			return this;
-		}
-
-		public ClientCallRule Succeeds(RuleOption<TimesHelper.AllTimes, int> times, int? validResponseCode = 200)
-		{
-			Self.Times = times;
-			Self.Succeeds = true;
-			Self.Return = validResponseCode;
-			return this;
-		}
-
-		public ClientCallRule AfterSucceeds(RuleOption<Exception, int> errorState = null)
-		{
-			Self.AfterSucceeds = errorState;
-			return this;
-		}
-
-		public ClientCallRule ThrowsAfterSucceeds()
-		{
-			Self.AfterSucceeds = new TheException();
-			return this;
-		}
-
-		public ClientCallRule SucceedAlways(int? validResponseCode = 200) => Succeeds(TimesHelper.Always, validResponseCode);
-
-		public ClientCallRule FailAlways(RuleOption<Exception, int> errorState = null) => Fails(TimesHelper.Always, errorState);
+		Self.Times = times;
+		Self.Succeeds = false;
+		Self.Return = errorState ?? new TheException();
+		return this;
 	}
+
+	public ClientCallRule Succeeds(RuleOption<TimesHelper.AllTimes, int> times, int? validResponseCode = 200)
+	{
+		Self.Times = times;
+		Self.Succeeds = true;
+		Self.Return = validResponseCode;
+		return this;
+	}
+
+	public ClientCallRule AfterSucceeds(RuleOption<Exception, int> errorState = null)
+	{
+		Self.AfterSucceeds = errorState;
+		return this;
+	}
+
+	public ClientCallRule ThrowsAfterSucceeds()
+	{
+		Self.AfterSucceeds = new TheException();
+		return this;
+	}
+
+	public ClientCallRule SucceedAlways(int? validResponseCode = 200) => Succeeds(TimesHelper.Always, validResponseCode);
+
+	public ClientCallRule FailAlways(RuleOption<Exception, int> errorState = null) => Fails(TimesHelper.Always, errorState);
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Rules/PingRule.cs b/src/Elastic.Transport.VirtualizedCluster/Rules/PingRule.cs
index 0e23584..a9c5d0b 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Rules/PingRule.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Rules/PingRule.cs
@@ -4,30 +4,29 @@
 
 using System;
 
-namespace Elastic.Transport.VirtualizedCluster.Rules
+namespace Elastic.Transport.VirtualizedCluster.Rules;
+
+public sealed class PingRule : RuleBase<PingRule>
 {
-	public class PingRule : RuleBase<PingRule>
-	{
-		private IRule Self => this;
+	private IRule Self => this;
 
-		public PingRule Fails(RuleOption<TimesHelper.AllTimes, int> times, RuleOption<Exception, int> errorState = null)
-		{
-			Self.Times = times;
-			Self.Succeeds = false;
-			Self.Return = errorState;
-			return this;
-		}
+	public PingRule Fails(RuleOption<TimesHelper.AllTimes, int> times, RuleOption<Exception, int> errorState = null)
+	{
+		Self.Times = times;
+		Self.Succeeds = false;
+		Self.Return = errorState;
+		return this;
+	}
 
-		public PingRule Succeeds(RuleOption<TimesHelper.AllTimes, int> times, int? validResponseCode = 200)
-		{
-			Self.Times = times;
-			Self.Succeeds = true;
-			Self.Return = validResponseCode;
-			return this;
-		}
+	public PingRule Succeeds(RuleOption<TimesHelper.AllTimes, int> times, int? validResponseCode = 200)
+	{
+		Self.Times = times;
+		Self.Succeeds = true;
+		Self.Return = validResponseCode;
+		return this;
+	}
 
-		public PingRule SucceedAlways(int? validResponseCode = 200) => Succeeds(TimesHelper.Always, validResponseCode);
+	public PingRule SucceedAlways(int? validResponseCode = 200) => Succeeds(TimesHelper.Always, validResponseCode);
 
-		public PingRule FailAlways(RuleOption<Exception, int> errorState = null) => Fails(TimesHelper.Always, errorState);
-	}
+	public PingRule FailAlways(RuleOption<Exception, int> errorState = null) => Fails(TimesHelper.Always, errorState);
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Rules/RuleBase.cs b/src/Elastic.Transport.VirtualizedCluster/Rules/RuleBase.cs
index 2deb967..855d497 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Rules/RuleBase.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Rules/RuleBase.cs
@@ -2,93 +2,92 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
- using System;
- using System.Threading;
+using System;
+using System.Threading;
 
-namespace Elastic.Transport.VirtualizedCluster.Rules
+namespace Elastic.Transport.VirtualizedCluster.Rules;
+
+public interface IRule
 {
-	public interface IRule
-	{
-		/// <summary>The value or exception to return after the call succeeds</summary>
-		RuleOption<Exception, int> AfterSucceeds { get; set; }
+	/// <summary>The value or exception to return after the call succeeds</summary>
+	RuleOption<Exception, int> AfterSucceeds { get; set; }
 
-		/// <summary>This rule is constrain on the node with this port number</summary>
-		int? OnPort { get; set; }
+	/// <summary>This rule is constrain on the node with this port number</summary>
+	int? OnPort { get; set; }
 
-		/// <summary> Either a hard exception or soft HTTP error code</summary>
-		RuleOption<Exception, int> Return { get; set; }
+	/// <summary> Either a hard exception or soft HTTP error code</summary>
+	RuleOption<Exception, int> Return { get; set; }
 
-		/// <summary>Set an explicit return content type for the API call</summary>
-		string ReturnContentType { get; set; }
+	/// <summary>Set an explicit return content type for the API call</summary>
+	string ReturnContentType { get; set; }
 
-		/// <summary>Explicitly set the bytes returned by the API call, optional.</summary>
-		byte[] ReturnResponse { get; set; }
+	/// <summary>Explicitly set the bytes returned by the API call, optional.</summary>
+	byte[] ReturnResponse { get; set; }
 
-		/// <summary>Whether this rule describes an API call succeeding or not</summary>
-		bool Succeeds { get; set; }
+	/// <summary>Whether this rule describes an API call succeeding or not</summary>
+	bool Succeeds { get; set; }
 
-		/// <summary>Simulate a long running call</summary>
-		TimeSpan? Takes { get; set; }
+	/// <summary>Simulate a long running call</summary>
+	TimeSpan? Takes { get; set; }
 
-		/// <summary> The number of times this rule stays valid after being called</summary>
-		RuleOption<TimesHelper.AllTimes, int> Times { get; set; }
+	/// <summary> The number of times this rule stays valid after being called</summary>
+	RuleOption<TimesHelper.AllTimes, int> Times { get; set; }
 
-		/// <summary> The amount of times this rule has been executed</summary>
-		int ExecuteCount { get; }
+	/// <summary> The amount of times this rule has been executed</summary>
+	int ExecuteCount { get; }
 
-		/// <summary> Mark a rule as executed </summary>
-		void RecordExecuted();
-	}
+	/// <summary> Mark a rule as executed </summary>
+	void RecordExecuted();
+}
 
-	public abstract class RuleBase<TRule> : IRule
-		where TRule : RuleBase<TRule>, IRule
+public abstract class RuleBase<TRule> : IRule
+	where TRule : RuleBase<TRule>, IRule
+{
+	private int _executeCount;
+	RuleOption<Exception, int> IRule.AfterSucceeds { get; set; }
+	int? IRule.OnPort { get; set; }
+	RuleOption<Exception, int> IRule.Return { get; set; }
+	string IRule.ReturnContentType { get; set; }
+	byte[] IRule.ReturnResponse { get; set; }
+	private IRule Self => this;
+	bool IRule.Succeeds { get; set; }
+	TimeSpan? IRule.Takes { get; set; }
+	RuleOption<TimesHelper.AllTimes, int> IRule.Times { get; set; }
+
+	int IRule.ExecuteCount => _executeCount;
+
+	void IRule.RecordExecuted() => Interlocked.Increment(ref _executeCount);
+
+	public TRule OnPort(int port)
 	{
-		private int _executeCount;
-		RuleOption<Exception, int> IRule.AfterSucceeds { get; set; }
-		int? IRule.OnPort { get; set; }
-		RuleOption<Exception, int> IRule.Return { get; set; }
-		string IRule.ReturnContentType { get; set; }
-		byte[] IRule.ReturnResponse { get; set; }
-		private IRule Self => this;
-		bool IRule.Succeeds { get; set; }
-		TimeSpan? IRule.Takes { get; set; }
-		RuleOption<TimesHelper.AllTimes, int> IRule.Times { get; set; }
-
-		int IRule.ExecuteCount => _executeCount;
-
-		void IRule.RecordExecuted() => Interlocked.Increment(ref _executeCount);
-
-		public TRule OnPort(int port)
-		{
-			Self.OnPort = port;
-			return (TRule)this;
-		}
+		Self.OnPort = port;
+		return (TRule)this;
+	}
 
-		public TRule Takes(TimeSpan span)
-		{
-			Self.Takes = span;
-			return (TRule)this;
-		}
+	public TRule Takes(TimeSpan span)
+	{
+		Self.Takes = span;
+		return (TRule)this;
+	}
 
-		public TRule ReturnResponse<T>(T response)
-			where T : class
+	public TRule ReturnResponse<T>(T response)
+		where T : class
+	{
+		byte[] r;
+		using (var ms = TransportConfiguration.DefaultMemoryStreamFactory.Create())
 		{
-			byte[] r;
-			using (var ms = TransportConfiguration.DefaultMemoryStreamFactory.Create())
-			{
-				LowLevelRequestResponseSerializer.Instance.Serialize(response, ms);
-				r = ms.ToArray();
-			}
-			Self.ReturnResponse = r;
-			Self.ReturnContentType = RequestData.MimeType;
-			return (TRule)this;
+			LowLevelRequestResponseSerializer.Instance.Serialize(response, ms);
+			r = ms.ToArray();
 		}
+		Self.ReturnResponse = r;
+		Self.ReturnContentType = RequestData.MimeType;
+		return (TRule)this;
+	}
 
-		public TRule ReturnByteResponse(byte[] response, string responseContentType = RequestData.MimeType)
-		{
-			Self.ReturnResponse = response;
-			Self.ReturnContentType = responseContentType;
-			return (TRule)this;
-		}
+	public TRule ReturnByteResponse(byte[] response, string responseContentType = RequestData.MimeType)
+	{
+		Self.ReturnResponse = response;
+		Self.ReturnContentType = responseContentType;
+		return (TRule)this;
 	}
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Rules/RuleOption.cs b/src/Elastic.Transport.VirtualizedCluster/Rules/RuleOption.cs
index 0aaae1b..fd24718 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Rules/RuleOption.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Rules/RuleOption.cs
@@ -4,76 +4,75 @@
 
 using System;
 
-namespace Elastic.Transport.VirtualizedCluster.Rules
+namespace Elastic.Transport.VirtualizedCluster.Rules;
+
+/// <summary>
+/// Represents the union of two types, <typeparamref name="TFirst" /> and <typeparamref name="TSecond" />.
+/// Used to represent a rule with multiple return states
+/// </summary>
+/// <typeparam name="TFirst">The first type</typeparam>
+/// <typeparam name="TSecond">The second type</typeparam>
+public sealed class RuleOption<TFirst, TSecond>
 {
+	internal readonly int Tag;
+	internal readonly TFirst Item1;
+	internal readonly TSecond Item2;
+
 	/// <summary>
-	/// Represents the union of two types, <typeparamref name="TFirst" /> and <typeparamref name="TSecond" />.
-	/// Used to represent a rule with multiple return states
+	/// Creates an new instance of <see cref="RuleOption{TFirst,TSecond}" /> that encapsulates <paramref name="item" /> value
 	/// </summary>
-	/// <typeparam name="TFirst">The first type</typeparam>
-	/// <typeparam name="TSecond">The second type</typeparam>
-	public class RuleOption<TFirst, TSecond>
+	/// <param name="item">The value to encapsulate</param>
+	public RuleOption(TFirst item)
 	{
-		internal readonly int Tag;
-		internal readonly TFirst Item1;
-		internal readonly TSecond Item2;
-
-		/// <summary>
-		/// Creates an new instance of <see cref="RuleOption{TFirst,TSecond}" /> that encapsulates <paramref name="item" /> value
-		/// </summary>
-		/// <param name="item">The value to encapsulate</param>
-		public RuleOption(TFirst item)
-		{
-			Item1 = item;
-			Tag = 0;
-		}
+		Item1 = item;
+		Tag = 0;
+	}
 
-		/// <summary>
-		/// Creates an new instance of <see cref="RuleOption{TFirst,TSecond}" /> that encapsulates <paramref name="item" /> value
-		/// </summary>
-		/// <param name="item">The value to encapsulate</param>
-		public RuleOption(TSecond item)
-		{
-			Item2 = item;
-			Tag = 1;
-		}
+	/// <summary>
+	/// Creates an new instance of <see cref="RuleOption{TFirst,TSecond}" /> that encapsulates <paramref name="item" /> value
+	/// </summary>
+	/// <param name="item">The value to encapsulate</param>
+	public RuleOption(TSecond item)
+	{
+		Item2 = item;
+		Tag = 1;
+	}
 
-		/// <summary>
-		/// Runs an <see cref="Action{T}" /> delegate against the encapsulated value
-		/// </summary>
-		/// <param name="first">The delegate to run when this instance encapsulates an instance of <typeparamref name="TFirst" /></param>
-		/// <param name="second">The delegate to run when this instance encapsulates an instance of <typeparamref name="TSecond" /></param>
-		public void Match(Action<TFirst> first, Action<TSecond> second)
+	/// <summary>
+	/// Runs an <see cref="Action{T}" /> delegate against the encapsulated value
+	/// </summary>
+	/// <param name="first">The delegate to run when this instance encapsulates an instance of <typeparamref name="TFirst" /></param>
+	/// <param name="second">The delegate to run when this instance encapsulates an instance of <typeparamref name="TSecond" /></param>
+	public void Match(Action<TFirst> first, Action<TSecond> second)
+	{
+		switch (Tag)
 		{
-			switch (Tag)
-			{
-				case 0:
-					first(Item1);
-					break;
-				case 1:
-					second(Item2);
-					break;
-				default: throw new Exception($"Unrecognized tag value: {Tag}");
-			}
+			case 0:
+				first(Item1);
+				break;
+			case 1:
+				second(Item2);
+				break;
+			default: throw new Exception($"Unrecognized tag value: {Tag}");
 		}
+	}
 
-		/// <summary>
-		/// Runs a <see cref="Func{T,TResult}" /> delegate against the encapsulated value
-		/// </summary>
-		/// <param name="first">The delegate to run when this instance encapsulates an instance of <typeparamref name="TFirst" /></param>
-		/// <param name="second">The delegate to run when this instance encapsulates an instance of <typeparamref name="TSecond" /></param>
-		public T Match<T>(Func<TFirst, T> first, Func<TSecond, T> second)
+	/// <summary>
+	/// Runs a <see cref="Func{T,TResult}" /> delegate against the encapsulated value
+	/// </summary>
+	/// <param name="first">The delegate to run when this instance encapsulates an instance of <typeparamref name="TFirst" /></param>
+	/// <param name="second">The delegate to run when this instance encapsulates an instance of <typeparamref name="TSecond" /></param>
+	public T Match<T>(Func<TFirst, T> first, Func<TSecond, T> second)
+	{
+		switch (Tag)
 		{
-			switch (Tag)
-			{
-				case 0: return first(Item1);
-				case 1: return second(Item2);
-				default: throw new Exception($"Unrecognized tag value: {Tag}");
-			}
+			case 0: return first(Item1);
+			case 1: return second(Item2);
+			default: throw new Exception($"Unrecognized tag value: {Tag}");
 		}
+	}
 
-		public static implicit operator RuleOption<TFirst, TSecond>(TFirst first) => new RuleOption<TFirst, TSecond>(first);
+	public static implicit operator RuleOption<TFirst, TSecond>(TFirst first) => new(first);
 
-		public static implicit operator RuleOption<TFirst, TSecond>(TSecond second) => new RuleOption<TFirst, TSecond>(second);
-	}
+	public static implicit operator RuleOption<TFirst, TSecond>(TSecond second) => new(second);
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Rules/SniffRule.cs b/src/Elastic.Transport.VirtualizedCluster/Rules/SniffRule.cs
index 0b73100..60b9a19 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Rules/SniffRule.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Rules/SniffRule.cs
@@ -5,38 +5,37 @@
 using System;
 using Elastic.Transport.VirtualizedCluster.Components;
 
-namespace Elastic.Transport.VirtualizedCluster.Rules
+namespace Elastic.Transport.VirtualizedCluster.Rules;
+
+public interface ISniffRule : IRule
+{
+	/// <summary> The new cluster state after the sniff returns </summary>
+	VirtualCluster NewClusterState { get; set; }
+}
+
+public sealed class SniffRule : RuleBase<SniffRule>, ISniffRule
 {
-	public interface ISniffRule : IRule
+	VirtualCluster ISniffRule.NewClusterState { get; set; }
+	private ISniffRule Self => this;
+
+	public SniffRule Fails(RuleOption<TimesHelper.AllTimes, int> times, RuleOption<Exception, int> errorState = null)
 	{
-		/// <summary> The new cluster state after the sniff returns </summary>
-		VirtualCluster NewClusterState { get; set; }
+		Self.Times = times;
+		Self.Succeeds = false;
+		Self.Return = errorState;
+		return this;
 	}
 
-	public class SniffRule : RuleBase<SniffRule>, ISniffRule
+	public SniffRule Succeeds(RuleOption<TimesHelper.AllTimes, int> times, VirtualCluster cluster = null)
 	{
-		VirtualCluster ISniffRule.NewClusterState { get; set; }
-		private ISniffRule Self => this;
-
-		public SniffRule Fails(RuleOption<TimesHelper.AllTimes, int> times, RuleOption<Exception, int> errorState = null)
-		{
-			Self.Times = times;
-			Self.Succeeds = false;
-			Self.Return = errorState;
-			return this;
-		}
-
-		public SniffRule Succeeds(RuleOption<TimesHelper.AllTimes, int> times, VirtualCluster cluster = null)
-		{
-			Self.Times = times;
-			Self.Succeeds = true;
-			Self.NewClusterState = cluster;
-			Self.Return = 200;
-			return this;
-		}
-
-		public SniffRule SucceedAlways(VirtualCluster cluster = null) => Succeeds(TimesHelper.Always, cluster);
-
-		public SniffRule FailAlways(RuleOption<Exception, int> errorState = null) => Fails(TimesHelper.Always, errorState);
+		Self.Times = times;
+		Self.Succeeds = true;
+		Self.NewClusterState = cluster;
+		Self.Return = 200;
+		return this;
 	}
+
+	public SniffRule SucceedAlways(VirtualCluster cluster = null) => Succeeds(TimesHelper.Always, cluster);
+
+	public SniffRule FailAlways(RuleOption<Exception, int> errorState = null) => Fails(TimesHelper.Always, errorState);
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Rules/TimesHelper.cs b/src/Elastic.Transport.VirtualizedCluster/Rules/TimesHelper.cs
index 3f7cddc..d47d64d 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Rules/TimesHelper.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Rules/TimesHelper.cs
@@ -4,19 +4,18 @@
 
 using System;
 
-namespace Elastic.Transport.VirtualizedCluster.Rules
+namespace Elastic.Transport.VirtualizedCluster.Rules;
+
+public static class TimesHelper
 {
-	public static class TimesHelper
-	{
-		public static AllTimes Always = new AllTimes();
-		public static readonly int Once = 0;
-		public static readonly int Twice = 1;
+	public static AllTimes Always = new();
+	public static readonly int Once = 0;
+	public static readonly int Twice = 1;
 
-		public static int Times(int n) => Math.Max(0, n - 1);
+	public static int Times(int n) => Math.Max(0, n - 1);
 
-		public class AllTimes
-		{
-			internal AllTimes() { }
-		}
+	public class AllTimes
+	{
+		internal AllTimes() { }
 	}
 }
diff --git a/src/Elastic.Transport.VirtualizedCluster/Setup.cs b/src/Elastic.Transport.VirtualizedCluster/Setup.cs
index cdc86f7..f48287f 100644
--- a/src/Elastic.Transport.VirtualizedCluster/Setup.cs
+++ b/src/Elastic.Transport.VirtualizedCluster/Setup.cs
@@ -4,8 +4,8 @@
 
 using Elastic.Transport.VirtualizedCluster.Products.Elasticsearch;
 
-namespace Elastic.Transport.VirtualizedCluster
-{
+namespace Elastic.Transport.VirtualizedCluster;
+
 	/// <summary>
 	/// Static factory class that can be used to bootstrap virtual product clusters. E.g a cluster of virtual Elasticsearch nodes.
 	/// </summary>
@@ -16,4 +16,3 @@ public static class Virtual
 		/// </summary>
 		public static ElasticsearchClusterFactory Elasticsearch { get; } = ElasticsearchClusterFactory.Default;
 	}
-}
diff --git a/src/Elastic.Transport/Components/NodePool/CloudNodePool.cs b/src/Elastic.Transport/Components/NodePool/CloudNodePool.cs
index c7b2413..54282d9 100644
--- a/src/Elastic.Transport/Components/NodePool/CloudNodePool.cs
+++ b/src/Elastic.Transport/Components/NodePool/CloudNodePool.cs
@@ -5,95 +5,94 @@
 using System;
 using System.Text;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// An <see cref="NodePool"/> implementation that can be seeded with a cloud id
+/// and will signal the right defaults for the client to use for Elastic Cloud to <see cref="ITransportConfiguration"/>.
+///
+/// <para>Read more about Elastic Cloud Id:</para>
+/// <para>https://www.elastic.co/guide/en/cloud/current/ec-cloud-id.html</para>
+/// </summary>
+public sealed class CloudNodePool : SingleNodePool
 {
 	/// <summary>
 	/// An <see cref="NodePool"/> implementation that can be seeded with a cloud id
 	/// and will signal the right defaults for the client to use for Elastic Cloud to <see cref="ITransportConfiguration"/>.
 	///
-	/// <para>Read more about Elastic Cloud Id:</para>
+	/// <para>Read more about Elastic Cloud Id here</para>
 	/// <para>https://www.elastic.co/guide/en/cloud/current/ec-cloud-id.html</para>
 	/// </summary>
-	public sealed class CloudNodePool : SingleNodePool
+	/// <param name="cloudId">
+	/// The Cloud Id, this is available on your cluster's dashboard and is a string in the form of <code>cluster_name:base_64_encoded_string</code>
+	/// <para>Base64 encoded string contains the following tokens in order separated by $:</para>
+	/// <para>* Host Name (mandatory)</para>
+	/// <para>* Elasticsearch UUID (mandatory)</para>
+	/// <para>* Kibana UUID</para>
+	/// <para>* APM UUID</para>
+	/// <para></para>
+	/// <para> We then use these tokens to create the URI to your Elastic Cloud cluster!</para>
+	/// <para></para>
+	/// <para> Read more here: https://www.elastic.co/guide/en/cloud/current/ec-cloud-id.html</para>
+	/// </param>
+	/// <param name="credentials"></param>
+	/// <param name="dateTimeProvider">Optionally inject an instance of <see cref="DateTimeProvider"/> used to set <see cref="NodePool.LastUpdate"/></param>
+	public CloudNodePool(string cloudId, AuthorizationHeader credentials, DateTimeProvider dateTimeProvider = null) : this(ParseCloudId(cloudId), dateTimeProvider) =>
+		AuthenticationHeader  = credentials;
+
+	private CloudNodePool(ParsedCloudId parsedCloudId, DateTimeProvider dateTimeProvider = null) : base(parsedCloudId.Uri, dateTimeProvider) =>
+		ClusterName = parsedCloudId.Name;
+
+	//TODO implement debugger display for NodePool implementations and display it there and its ToString()
+	// ReSharper disable once UnusedAutoPropertyAccessor.Local
+	private string ClusterName { get; }
+
+	/// <inheritdoc cref="AuthorizationHeader"/>
+	public AuthorizationHeader AuthenticationHeader { get; }
+
+	private readonly struct ParsedCloudId
 	{
-		/// <summary>
-		/// An <see cref="NodePool"/> implementation that can be seeded with a cloud id
-		/// and will signal the right defaults for the client to use for Elastic Cloud to <see cref="ITransportConfiguration"/>.
-		///
-		/// <para>Read more about Elastic Cloud Id here</para>
-		/// <para>https://www.elastic.co/guide/en/cloud/current/ec-cloud-id.html</para>
-		/// </summary>
-		/// <param name="cloudId">
-		/// The Cloud Id, this is available on your cluster's dashboard and is a string in the form of <code>cluster_name:base_64_encoded_string</code>
-		/// <para>Base64 encoded string contains the following tokens in order separated by $:</para>
-		/// <para>* Host Name (mandatory)</para>
-		/// <para>* Elasticsearch UUID (mandatory)</para>
-		/// <para>* Kibana UUID</para>
-		/// <para>* APM UUID</para>
-		/// <para></para>
-		/// <para> We then use these tokens to create the URI to your Elastic Cloud cluster!</para>
-		/// <para></para>
-		/// <para> Read more here: https://www.elastic.co/guide/en/cloud/current/ec-cloud-id.html</para>
-		/// </param>
-		/// <param name="credentials"></param>
-		/// <param name="dateTimeProvider">Optionally inject an instance of <see cref="IDateTimeProvider"/> used to set <see cref="NodePool.LastUpdate"/></param>
-		public CloudNodePool(string cloudId, AuthorizationHeader credentials, IDateTimeProvider dateTimeProvider = null) : this(ParseCloudId(cloudId), dateTimeProvider) =>
-			AuthenticationHeader  = credentials;
-
-		private CloudNodePool(ParsedCloudId parsedCloudId, IDateTimeProvider dateTimeProvider = null) : base(parsedCloudId.Uri, dateTimeProvider) =>
-			ClusterName = parsedCloudId.Name;
-
-		//TODO implement debugger display for NodePool implementations and display it there and its ToString()
-		// ReSharper disable once UnusedAutoPropertyAccessor.Local
-		private string ClusterName { get; }
-
-		/// <inheritdoc cref="AuthorizationHeader"/>
-		public AuthorizationHeader AuthenticationHeader { get; }
-
-		private readonly struct ParsedCloudId
+		public ParsedCloudId(string clusterName, Uri uri)
 		{
-			public ParsedCloudId(string clusterName, Uri uri)
-			{
-				Name = clusterName;
-				Uri = uri;
-			}
-
-			public string Name { get; }
-			public Uri Uri { get; }
+			Name = clusterName;
+			Uri = uri;
 		}
 
-		private static ParsedCloudId ParseCloudId(string cloudId)
-		{
-			const string exceptionSuffix = "should be a string in the form of cluster_name:base_64_data";
-			if (string.IsNullOrWhiteSpace(cloudId))
-				throw new ArgumentException($"Parameter {nameof(cloudId)} was null or empty but {exceptionSuffix}", nameof(cloudId));
+		public string Name { get; }
+		public Uri Uri { get; }
+	}
 
-			var tokens = cloudId.Split(new[] { ':' }, 2);
-			if (tokens.Length != 2)
-				throw new ArgumentException($"Parameter {nameof(cloudId)} not in expected format, {exceptionSuffix}", nameof(cloudId));
+	private static ParsedCloudId ParseCloudId(string cloudId)
+	{
+		const string exceptionSuffix = "should be a string in the form of cluster_name:base_64_data";
+		if (string.IsNullOrWhiteSpace(cloudId))
+			throw new ArgumentException($"Parameter {nameof(cloudId)} was null or empty but {exceptionSuffix}", nameof(cloudId));
 
-			var clusterName = tokens[0];
-			var encoded = tokens[1];
-			if (string.IsNullOrWhiteSpace(encoded))
-				throw new ArgumentException($"Parameter {nameof(cloudId)} base_64_data is empty, {exceptionSuffix}", nameof(cloudId));
+		var tokens = cloudId.Split(new[] { ':' }, 2);
+		if (tokens.Length != 2)
+			throw new ArgumentException($"Parameter {nameof(cloudId)} not in expected format, {exceptionSuffix}", nameof(cloudId));
 
-			var decoded = Encoding.UTF8.GetString(Convert.FromBase64String(encoded));
-			var parts = decoded.Split(new[] { '$' });
-			if (parts.Length < 2)
-				throw new ArgumentException($"Parameter {nameof(cloudId)} decoded base_64_data contains less then 2 tokens, {exceptionSuffix}", nameof(cloudId));
+		var clusterName = tokens[0];
+		var encoded = tokens[1];
+		if (string.IsNullOrWhiteSpace(encoded))
+			throw new ArgumentException($"Parameter {nameof(cloudId)} base_64_data is empty, {exceptionSuffix}", nameof(cloudId));
 
-			var domainName = parts[0].Trim();
-			if (string.IsNullOrWhiteSpace(domainName))
-				throw new ArgumentException($"Parameter {nameof(cloudId)} decoded base_64_data contains no domain name, {exceptionSuffix}", nameof(cloudId));
+		var decoded = Encoding.UTF8.GetString(Convert.FromBase64String(encoded));
+		var parts = decoded.Split(new[] { '$' });
+		if (parts.Length < 2)
+			throw new ArgumentException($"Parameter {nameof(cloudId)} decoded base_64_data contains less then 2 tokens, {exceptionSuffix}", nameof(cloudId));
 
-			var elasticsearchUuid = parts[1].Trim();
-			if (string.IsNullOrWhiteSpace(elasticsearchUuid))
-				throw new ArgumentException($"Parameter {nameof(cloudId)} decoded base_64_data contains no elasticsearch UUID, {exceptionSuffix}", nameof(cloudId));
+		var domainName = parts[0].Trim();
+		if (string.IsNullOrWhiteSpace(domainName))
+			throw new ArgumentException($"Parameter {nameof(cloudId)} decoded base_64_data contains no domain name, {exceptionSuffix}", nameof(cloudId));
 
-			return new ParsedCloudId(clusterName, new Uri($"https://{elasticsearchUuid}.{domainName}"));
-		}
+		var elasticsearchUuid = parts[1].Trim();
+		if (string.IsNullOrWhiteSpace(elasticsearchUuid))
+			throw new ArgumentException($"Parameter {nameof(cloudId)} decoded base_64_data contains no elasticsearch UUID, {exceptionSuffix}", nameof(cloudId));
 
-		/// <inheritdoc />
-		protected override void Dispose(bool disposing) => base.Dispose(disposing);
+		return new ParsedCloudId(clusterName, new Uri($"https://{elasticsearchUuid}.{domainName}"));
 	}
+
+	/// <inheritdoc />
+	protected override void Dispose(bool disposing) => base.Dispose(disposing);
 }
diff --git a/src/Elastic.Transport/Components/NodePool/Node.cs b/src/Elastic.Transport/Components/NodePool/Node.cs
index f943d8b..2940d20 100644
--- a/src/Elastic.Transport/Components/NodePool/Node.cs
+++ b/src/Elastic.Transport/Components/NodePool/Node.cs
@@ -7,158 +7,157 @@
 using System.Linq;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Represents an endpoint <see cref="Uri"/> with additional associated metadata on which the <see cref="HttpTransport{TConnectionSettings}"/> can act.
+/// </summary>
+public sealed class Node : IEquatable<Node>
 {
+	private IReadOnlyCollection<string> _features;
+
+	/// <inheritdoc cref="Node"/>
+	public Node(Uri uri, IEnumerable<string> features = null)
+	{
+		// This make sures that a node can be rooted at a path to. Without the trailing slash Uri's will remove `instance` from
+		// http://my-saas-provider.com/instance
+		// Where this might be the user specific path
+		if (!uri.OriginalString.EndsWith("/", StringComparison.Ordinal))
+			uri = new Uri(uri.OriginalString + "/");
+		Uri = uri;
+		IsAlive = true;
+		if (features is IReadOnlyCollection<string> s)
+			Features = s;
+		else
+			Features = features?.ToList().AsReadOnly() ?? EmptyReadOnly<string>.Collection;
+		IsResurrected = true;
+	}
+
+	private HashSet<string> _featureSet;
+
 	/// <summary>
-	/// Represents an endpoint <see cref="Uri"/> with additional associated metadata on which the <see cref="ITransport{TConnectionSettings}"/> can act.
+	/// A readonly collection backed by an <see cref="HashSet{T}"/> that signals what features are enabled on the node.
+	/// <para> This is loosely typed as to be agnostic to what solution the transport ends up talking to </para>
 	/// </summary>
-	public sealed class Node : IEquatable<Node>
+	public IReadOnlyCollection<string> Features
 	{
-		private IReadOnlyCollection<string> _features;
-
-		/// <inheritdoc cref="Node"/>
-		public Node(Uri uri, IEnumerable<string> features = null)
+		get => _features;
+		set
 		{
-			// This make sures that a node can be rooted at a path to. Without the trailing slash Uri's will remove `instance` from
-			// http://my-saas-provider.com/instance
-			// Where this might be the user specific path
-			if (!uri.OriginalString.EndsWith("/", StringComparison.Ordinal))
-				uri = new Uri(uri.OriginalString + "/");
-			Uri = uri;
-			IsAlive = true;
-			if (features is IReadOnlyCollection<string> s)
-				Features = s;
-			else
-				Features = features?.ToList().AsReadOnly() ?? EmptyReadOnly<string>.Collection;
-			IsResurrected = true;
+			_features = value;
+			_featureSet = new HashSet<string>(_features);
 		}
+	}
 
-		private HashSet<string> _featureSet;
-
-		/// <summary>
-		/// A readonly collection backed by an <see cref="HashSet{T}"/> that signals what features are enabled on the node.
-		/// <para> This is loosely typed as to be agnostic to what solution the transport ends up talking to </para>
-		/// </summary>
-		public IReadOnlyCollection<string> Features
-		{
-			get => _features;
-			set
-			{
-				_features = value;
-				_featureSet = new HashSet<string>(_features);
-			}
-		}
+	/// <summary>
+	/// Settings as returned by the server, can be used in various ways later on. E.g <see cref="ITransportConfiguration.NodePredicate"/> can use it
+	/// to only select certain nodes with a setting
+	/// </summary>
+	public IReadOnlyDictionary<string, object> Settings { get; set; } = EmptyReadOnly<string, object>.Dictionary;
 
-		/// <summary>
-		/// Settings as returned by the server, can be used in various ways later on. E.g <see cref="ITransportConfiguration.NodePredicate"/> can use it
-		/// to only select certain nodes with a setting
-		/// </summary>
-		public IReadOnlyDictionary<string, object> Settings { get; set; } = EmptyReadOnly<string, object>.Dictionary;
+	/// <summary>The id of the node, defaults to null when unknown/unspecified</summary>
+	public string Id { get; internal set; }
 
-		/// <summary>The id of the node, defaults to null when unknown/unspecified</summary>
-		public string Id { get; internal set; }
+	/// <summary>The name of the node, defaults to null when unknown/unspecified</summary>
+	public string Name { get; set; }
 
-		/// <summary>The name of the node, defaults to null when unknown/unspecified</summary>
-		public string Name { get; set; }
+	/// <summary> The base endpoint where the node can be reached </summary>
+	public Uri Uri { get; }
 
-		/// <summary> The base endpoint where the node can be reached </summary>
-		public Uri Uri { get; }
+	/// <summary>
+	/// Indicates whether the node is alive. <see cref="HttpTransport{TConnectionSettings}"/> can take nodes out of rotation by calling
+	/// <see cref="MarkDead"/> on <see cref="Node"/>.
+	/// </summary>
+	public bool IsAlive { get; private set; }
 
-		/// <summary>
-		/// Indicates whether the node is alive. <see cref="ITransport{TConnectionSettings}"/> can take nodes out of rotation by calling
-		/// <see cref="MarkDead"/> on <see cref="Node"/>.
-		/// </summary>
-		public bool IsAlive { get; private set; }
+	/// <summary> When marked dead this reflects the date that the node has to be taken out of rotation till</summary>
+	public DateTime DeadUntil { get; private set; }
 
-		/// <summary> When marked dead this reflects the date that the node has to be taken out of rotation till</summary>
-		public DateTime DeadUntil { get; private set; }
+	/// <summary> The number of failed attempts trying to use this node, resets when a node is marked alive</summary>
+	public int FailedAttempts { get; private set; }
 
-		/// <summary> The number of failed attempts trying to use this node, resets when a node is marked alive</summary>
-		public int FailedAttempts { get; private set; }
+	/// <summary> When set this signals the transport that a ping before first usage would be wise</summary>
+	public bool IsResurrected { get; set; }
 
-		/// <summary> When set this signals the transport that a ping before first usage would be wise</summary>
-		public bool IsResurrected { get; set; }
+	/// <summary>
+	/// Returns true if the <see cref="Features"/> has <paramref name="feature"/> enabled, or NO features are known on the node.
+	/// <para>The assumption being if no <see cref="Features"/> have been discovered ALL features are enabled</para>
+	/// </summary>
+	public bool HasFeature(string feature) => _features.Count == 0 || _featureSet.Contains(feature);
 
-		/// <summary>
-		/// Returns true if the <see cref="Features"/> has <paramref name="feature"/> enabled, or NO features are known on the node.
-		/// <para>The assumption being if no <see cref="Features"/> have been discovered ALL features are enabled</para>
-		/// </summary>
-		public bool HasFeature(string feature) => _features.Count == 0 || _featureSet.Contains(feature);
 
+	/// <summary>
+	/// Marks this node as dead and set the date (see <paramref name="untill"/>) after which we want it to come back alive
+	/// </summary>
+	/// <param name="untill">The <see cref="DateTime"/> after which this node should be considered alive again</param>
+	public void MarkDead(DateTime untill)
+	{
+		FailedAttempts++;
+		IsAlive = false;
+		IsResurrected = false;
+		DeadUntil = untill;
+	}
 
-		/// <summary>
-		/// Marks this node as dead and set the date (see <paramref name="untill"/>) after which we want it to come back alive
-		/// </summary>
-		/// <param name="untill">The <see cref="DateTime"/> after which this node should be considered alive again</param>
-		public void MarkDead(DateTime untill)
-		{
-			FailedAttempts++;
-			IsAlive = false;
-			IsResurrected = false;
-			DeadUntil = untill;
-		}
+	/// <summary> Mark the node alive explicitly </summary>
+	public void MarkAlive()
+	{
+		FailedAttempts = 0;
+		IsAlive = true;
+		IsResurrected = false;
+		DeadUntil = default(DateTime);
+	}
 
-		/// <summary> Mark the node alive explicitly </summary>
-		public void MarkAlive()
-		{
-			FailedAttempts = 0;
-			IsAlive = true;
-			IsResurrected = false;
-			DeadUntil = default(DateTime);
-		}
+	/// <summary>
+	/// Use the nodes uri as root to create a <see cref="Uri"/> with <paramref name="path"/>
+	/// </summary>
+	public Uri CreatePath(string path) => new Uri(Uri, path);
 
-		/// <summary>
-		/// Use the nodes uri as root to create a <see cref="Uri"/> with <paramref name="path"/>
-		/// </summary>
-		public Uri CreatePath(string path) => new Uri(Uri, path);
-
-		/// <summary>
-		/// Create a clone of the current node. This is used by <see cref="NodePool"/> implementations that supports reseeding the
-		/// list of nodes through <see cref="NodePool.Reseed"/>
-		/// </summary>
-		public Node Clone() =>
-			new Node(Uri, Features)
-			{
-				IsResurrected = IsResurrected,
-				Id = Id,
-				Name = Name,
-				FailedAttempts = FailedAttempts,
-				DeadUntil = DeadUntil,
-				IsAlive = IsAlive,
-				Settings = Settings,
-			};
-
-		/// <summary> Two <see cref="Node"/>'s that point to the same <see cref="Uri"/> are considered equal</summary>
-		public bool Equals(Node other)
+	/// <summary>
+	/// Create a clone of the current node. This is used by <see cref="NodePool"/> implementations that supports reseeding the
+	/// list of nodes through <see cref="NodePool.Reseed"/>
+	/// </summary>
+	public Node Clone() =>
+		new Node(Uri, Features)
 		{
-			if (ReferenceEquals(null, other)) return false;
-			if (ReferenceEquals(this, other)) return true;
+			IsResurrected = IsResurrected,
+			Id = Id,
+			Name = Name,
+			FailedAttempts = FailedAttempts,
+			DeadUntil = DeadUntil,
+			IsAlive = IsAlive,
+			Settings = Settings,
+		};
+
+	/// <summary> Two <see cref="Node"/>'s that point to the same <see cref="Uri"/> are considered equal</summary>
+	public bool Equals(Node other)
+	{
+		if (ReferenceEquals(null, other)) return false;
+		if (ReferenceEquals(this, other)) return true;
 
-			return Uri == other.Uri;
-		}
+		return Uri == other.Uri;
+	}
 
-		/// <inheritdoc cref="Equals(Node)"/>
-		public static bool operator ==(Node left, Node right) =>
-			// ReSharper disable once MergeConditionalExpression
-			ReferenceEquals(left, null) ? ReferenceEquals(right, null) : left.Equals(right);
+	/// <inheritdoc cref="Equals(Node)"/>
+	public static bool operator ==(Node left, Node right) =>
+		// ReSharper disable once MergeConditionalExpression
+		ReferenceEquals(left, null) ? ReferenceEquals(right, null) : left.Equals(right);
 
-		/// <inheritdoc cref="Equals(Node)"/>
-		public static bool operator !=(Node left, Node right) => !(left == right);
+	/// <inheritdoc cref="Equals(Node)"/>
+	public static bool operator !=(Node left, Node right) => !(left == right);
 
-		/// <inheritdoc cref="Equals(Node)"/>
-		public static implicit operator Node(Uri uri) => new Node(uri);
+	/// <inheritdoc cref="Equals(Node)"/>
+	public static implicit operator Node(Uri uri) => new Node(uri);
 
-		/// <inheritdoc cref="Equals(Node)"/>
-		public override bool Equals(object obj)
-		{
-			if (ReferenceEquals(null, obj)) return false;
-			if (ReferenceEquals(this, obj)) return true;
-			if (obj.GetType() != GetType()) return false;
-
-			return Equals((Node)obj);
-		}
+	/// <inheritdoc cref="Equals(Node)"/>
+	public override bool Equals(object obj)
+	{
+		if (ReferenceEquals(null, obj)) return false;
+		if (ReferenceEquals(this, obj)) return true;
+		if (obj.GetType() != GetType()) return false;
 
-		/// <summary> A nodes identify is solely based on its <see cref="Uri"/> </summary>
-		public override int GetHashCode() => Uri.GetHashCode();
+		return Equals((Node)obj);
 	}
+
+	/// <summary> A nodes identify is solely based on its <see cref="Uri"/> </summary>
+	public override int GetHashCode() => Uri.GetHashCode();
 }
diff --git a/src/Elastic.Transport/Components/NodePool/NodePool.cs b/src/Elastic.Transport/Components/NodePool/NodePool.cs
index 629a23d..5f6492d 100644
--- a/src/Elastic.Transport/Components/NodePool/NodePool.cs
+++ b/src/Elastic.Transport/Components/NodePool/NodePool.cs
@@ -6,96 +6,95 @@
 using System.Collections.Generic;
 using Elastic.Transport.Diagnostics.Auditing;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A node pool is responsible for maintaining a read only collection of <see cref="Node"/>(s) under <see cref="Nodes"/>.
+/// <para>
+/// Unlike the name might suggest this component is not responsible for IO level pooling. For that we rely on <see cref="TransportClient"/> abstracting away
+/// the connection IO pooling.
+/// </para>
+/// <para>This interface signals the current connection strategy to <see cref="HttpTransport{TConnectionSettings}"/>.</para>
+/// </summary>
+public abstract class NodePool : IDisposable
 {
+	private bool _disposed;
+
 	/// <summary>
-	/// A node pool is responsible for maintaining a read only collection of <see cref="Node"/>(s) under <see cref="Nodes"/>.
-	/// <para>
-	/// Unlike the name might suggest this component is not responsible for IO level pooling. For that we rely on <see cref="ITransportClient"/> abstracting away
-	/// the connection IO pooling.
-	/// </para>
-	/// <para>This interface signals the current connection strategy to <see cref="ITransport{TConnectionSettings}"/>.</para>
+	/// The last time that this instance was updated.
 	/// </summary>
-	public abstract class NodePool : IDisposable
-	{
-		private bool _disposed;
+	public abstract DateTime LastUpdate { get; protected set; }
 
-		/// <summary>
-		/// The last time that this instance was updated.
-		/// </summary>
-		public abstract DateTime LastUpdate { get; protected set; }
-
-		/// <summary>
-		/// Returns the default maximum retries for the connection pool implementation.
-		/// Most implementations default to number of nodes, note that this can be overridden
-		/// in the connection settings.
-		/// </summary>
-		public abstract int MaxRetries { get; }
+	/// <summary>
+	/// Returns the default maximum retries for the connection pool implementation.
+	/// Most implementations default to number of nodes, note that this can be overridden
+	/// in the connection settings.
+	/// </summary>
+	public abstract int MaxRetries { get; }
 
-		/// <summary>
-		/// Returns a read only view of all the nodes in the cluster, which might involve creating copies of nodes e.g
-		/// if you are using <see cref="SniffingNodePool" />.
-		/// If you do not need an isolated copy of the nodes, please read <see cref="CreateView" /> to completion.
-		/// </summary>
-		public abstract IReadOnlyCollection<Node> Nodes { get; }
+	/// <summary>
+	/// Returns a read only view of all the nodes in the cluster, which might involve creating copies of nodes e.g
+	/// if you are using <see cref="SniffingNodePool" />.
+	/// If you do not need an isolated copy of the nodes, please read <see cref="CreateView" /> to completion.
+	/// </summary>
+	public abstract IReadOnlyCollection<Node> Nodes { get; }
 
-		/// <summary>
-		/// Whether a sniff is seen on startup.
-		/// </summary>
-		public bool SniffedOnStartup { get; private set; }
+	/// <summary>
+	/// Whether a sniff is seen on startup.
+	/// </summary>
+	public bool SniffedOnStartup { get; private set; }
 
-		/// <summary>
-		/// Whether a sniff is seen on startup. The implementation is
-		/// responsible for setting this in a thread safe fashion.
-		/// </summary>
-		public void MarkAsSniffed() => SniffedOnStartup = true;
+	/// <summary>
+	/// Whether a sniff is seen on startup. The implementation is
+	/// responsible for setting this in a thread safe fashion.
+	/// </summary>
+	public void MarkAsSniffed() => SniffedOnStartup = true;
 
-		/// <summary>
-		/// Whether pinging is supported.
-		/// </summary>
-		public abstract bool SupportsPinging { get; }
+	/// <summary>
+	/// Whether pinging is supported.
+	/// </summary>
+	public abstract bool SupportsPinging { get; }
 
-		/// <summary>
-		/// Whether reseeding with new nodes is supported.
-		/// </summary>
-		public abstract bool SupportsReseeding { get; }
+	/// <summary>
+	/// Whether reseeding with new nodes is supported.
+	/// </summary>
+	public abstract bool SupportsReseeding { get; }
 
-		/// <summary>
-		/// Whether SSL/TLS is being used.
-		/// </summary>
-		public abstract bool UsingSsl { get; protected set; }
+	/// <summary>
+	/// Whether SSL/TLS is being used.
+	/// </summary>
+	public abstract bool UsingSsl { get; protected set; }
 
-		/// <summary>
-		/// 
-		/// </summary>
-		public void Dispose()
-		{
-			Dispose(true);
-			GC.SuppressFinalize(this);
-		}
+	/// <summary>
+	/// 
+	/// </summary>
+	public void Dispose()
+	{
+		Dispose(true);
+		GC.SuppressFinalize(this);
+	}
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="disposing"></param>
-		protected virtual void Dispose(bool disposing)
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="disposing"></param>
+	protected virtual void Dispose(bool disposing)
+	{
+		if (!_disposed)
 		{
-			if (!_disposed)
-			{
-				_disposed = true;
-			}
+			_disposed = true;
 		}
+	}
 
-		/// <summary>
-		/// Creates a view over the nodes, with changing starting positions, that wraps over on each call
-		/// e.g Thread A might get 1,2,3,4,5 and thread B will get 2,3,4,5,1.
-		/// if there are no live nodes yields a different dead node to try once
-		/// </summary>
-		public abstract IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null);
+	/// <summary>
+	/// Creates a view over the nodes, with changing starting positions, that wraps over on each call
+	/// e.g Thread A might get 1,2,3,4,5 and thread B will get 2,3,4,5,1.
+	/// if there are no live nodes yields a different dead node to try once
+	/// </summary>
+	public abstract IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null);
 
-		/// <summary>
-		/// Reseeds the nodes. The implementation is responsible for thread safety.
-		/// </summary>
-		public abstract void Reseed(IEnumerable<Node> nodes);
-	}
+	/// <summary>
+	/// Reseeds the nodes. The implementation is responsible for thread safety.
+	/// </summary>
+	public abstract void Reseed(IEnumerable<Node> nodes);
 }
diff --git a/src/Elastic.Transport/Components/NodePool/SingleNodePool.cs b/src/Elastic.Transport/Components/NodePool/SingleNodePool.cs
index 5465077..34bbf19 100644
--- a/src/Elastic.Transport/Components/NodePool/SingleNodePool.cs
+++ b/src/Elastic.Transport/Components/NodePool/SingleNodePool.cs
@@ -6,45 +6,44 @@
 using System.Collections.Generic;
 using Elastic.Transport.Diagnostics.Auditing;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary> A pool to a single node or endpoint.</summary>
+public class SingleNodePool : NodePool
 {
-	/// <summary> A pool to a single node or endpoint.</summary>
-	public class SingleNodePool : NodePool
+	/// <inheritdoc cref="SingleNodePool"/>
+	public SingleNodePool(Uri uri, DateTimeProvider dateTimeProvider = null)
 	{
-		/// <inheritdoc cref="SingleNodePool"/>
-		public SingleNodePool(Uri uri, IDateTimeProvider dateTimeProvider = null)
-		{
-			var node = new Node(uri);
-			UsingSsl = node.Uri.Scheme == "https";
-			Nodes = new List<Node> { node };
-			LastUpdate = (dateTimeProvider ?? DateTimeProvider.Default).Now();
-		}
+		var node = new Node(uri);
+		UsingSsl = node.Uri.Scheme == "https";
+		Nodes = new List<Node> { node };
+		LastUpdate = (dateTimeProvider ?? DefaultDateTimeProvider.Default).Now();
+	}
 
-		/// <inheritdoc />
-		public override DateTime LastUpdate { get; protected set; }
+	/// <inheritdoc />
+	public override DateTime LastUpdate { get; protected set; }
 
-		/// <inheritdoc />
-		public override int MaxRetries => 0;
+	/// <inheritdoc />
+	public override int MaxRetries => 0;
 
-		/// <inheritdoc />
-		public override IReadOnlyCollection<Node> Nodes { get; }
+	/// <inheritdoc />
+	public override IReadOnlyCollection<Node> Nodes { get; }
 
-		/// <inheritdoc />
-		public override bool SupportsPinging => false;
+	/// <inheritdoc />
+	public override bool SupportsPinging => false;
 
-		/// <inheritdoc />
-		public override bool SupportsReseeding => false;
+	/// <inheritdoc />
+	public override bool SupportsReseeding => false;
 
-		/// <inheritdoc />
-		public override bool UsingSsl { get; protected set; }
+	/// <inheritdoc />
+	public override bool UsingSsl { get; protected set; }
 
-		/// <inheritdoc />
-		public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null) => Nodes;
+	/// <inheritdoc />
+	public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null) => Nodes;
 
-		/// <inheritdoc />
-		public override void Reseed(IEnumerable<Node> nodes) { } //ignored
+	/// <inheritdoc />
+	public override void Reseed(IEnumerable<Node> nodes) { } //ignored
 
-		/// <inheritdoc />
-		protected override void Dispose(bool disposing) => base.Dispose(disposing);
-	}
+	/// <inheritdoc />
+	protected override void Dispose(bool disposing) => base.Dispose(disposing);
 }
diff --git a/src/Elastic.Transport/Components/NodePool/SniffingNodePool.cs b/src/Elastic.Transport/Components/NodePool/SniffingNodePool.cs
index 05dd520..3c88c1c 100644
--- a/src/Elastic.Transport/Components/NodePool/SniffingNodePool.cs
+++ b/src/Elastic.Transport/Components/NodePool/SniffingNodePool.cs
@@ -9,105 +9,104 @@
 using Elastic.Transport.Diagnostics.Auditing;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A node pool that enables <see cref="SupportsReseeding"/> which in turn allows the <see cref="HttpTransport{TConnectionSettings}"/> to enable sniffing to
+/// discover the current cluster's list of active nodes.
+/// </summary>
+public class SniffingNodePool : StaticNodePool
 {
-	/// <summary>
-	/// A node pool that enables <see cref="SupportsReseeding"/> which in turn allows the <see cref="ITransport{TConnectionSettings}"/> to enable sniffing to
-	/// discover the current cluster's list of active nodes.
-	/// </summary>
-	public class SniffingNodePool : StaticNodePool
-	{
-		private bool _disposed;
+	private bool _disposed;
 
-		private readonly ReaderWriterLockSlim _readerWriter = new();
+	private readonly ReaderWriterLockSlim _readerWriter = new();
 
-		/// <inheritdoc cref="SniffingNodePool"/>>
-		public SniffingNodePool(IEnumerable<Uri> uris, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
-			: base(uris, randomize, dateTimeProvider) { }
+	/// <inheritdoc cref="SniffingNodePool"/>>
+	public SniffingNodePool(IEnumerable<Uri> uris, bool randomize = true, DateTimeProvider dateTimeProvider = null)
+		: base(uris, randomize, dateTimeProvider) { }
 
-		/// <inheritdoc cref="SniffingNodePool"/>>
-		public SniffingNodePool(IEnumerable<Node> nodes, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
-			: base(nodes, randomize, dateTimeProvider) { }
+	/// <inheritdoc cref="SniffingNodePool"/>>
+	public SniffingNodePool(IEnumerable<Node> nodes, bool randomize = true, DateTimeProvider dateTimeProvider = null)
+		: base(nodes, randomize, dateTimeProvider) { }
 
-		/// <inheritdoc cref="SniffingNodePool"/>>
-		public SniffingNodePool(IEnumerable<Node> nodes, Func<Node, float> nodeScorer, IDateTimeProvider dateTimeProvider = null)
-			: base(nodes, nodeScorer, dateTimeProvider) { }
+	/// <inheritdoc cref="SniffingNodePool"/>>
+	public SniffingNodePool(IEnumerable<Node> nodes, Func<Node, float> nodeScorer, DateTimeProvider dateTimeProvider = null)
+		: base(nodes, nodeScorer, dateTimeProvider) { }
 
-		/// <inheritdoc />
-		public override IReadOnlyCollection<Node> Nodes
+	/// <inheritdoc />
+	public override IReadOnlyCollection<Node> Nodes
+	{
+		get
 		{
-			get
+			try
 			{
-				try
-				{
-					//since internalnodes can be changed after returning we return
-					//a completely new list of cloned nodes
-					_readerWriter.EnterReadLock();
-					return InternalNodes.Select(n => n.Clone()).ToList();
-				}
-				finally
-				{
-					_readerWriter.ExitReadLock();
-				}
+				//since internalnodes can be changed after returning we return
+				//a completely new list of cloned nodes
+				_readerWriter.EnterReadLock();
+				return InternalNodes.Select(n => n.Clone()).ToList();
+			}
+			finally
+			{
+				_readerWriter.ExitReadLock();
 			}
 		}
+	}
 
-		/// <inheritdoc />
-		public override bool SupportsPinging => true;
+	/// <inheritdoc />
+	public override bool SupportsPinging => true;
 
-		/// <inheritdoc />
-		public override bool SupportsReseeding => true;
+	/// <inheritdoc />
+	public override bool SupportsReseeding => true;
 
-		/// <inheritdoc />
-		public override void Reseed(IEnumerable<Node> nodes)
-		{
-			if (!nodes.HasAny(out var nodesArray)) return;
+	/// <inheritdoc />
+	public override void Reseed(IEnumerable<Node> nodes)
+	{
+		if (!nodes.HasAny(out var nodesArray)) return;
 
-			try
-			{
-				_readerWriter.EnterWriteLock();
-				var sortedNodes = SortNodes(nodesArray)
-					.DistinctByCustom(n => n.Uri)
-					.ToList();
-
-				InternalNodes = sortedNodes;
-				GlobalCursor = -1;
-				LastUpdate = DateTimeProvider.Now();
-			}
-			finally
-			{
-				_readerWriter.ExitWriteLock();
-			}
+		try
+		{
+			_readerWriter.EnterWriteLock();
+			var sortedNodes = SortNodes(nodesArray)
+				.DistinctByCustom(n => n.Uri)
+				.ToList();
+
+			InternalNodes = sortedNodes;
+			GlobalCursor = -1;
+			LastUpdate = DateTimeProvider.Now();
 		}
+		finally
+		{
+			_readerWriter.ExitWriteLock();
+		}
+	}
 
-		/// <inheritdoc />
-		public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null)
+	/// <inheritdoc />
+	public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null)
+	{
+		_readerWriter.EnterReadLock();
+		try
 		{
-			_readerWriter.EnterReadLock();
-			try
-			{
-				return base.CreateView(audit);
-			}
-			finally
-			{
-				_readerWriter.ExitReadLock();
-			}
+			return base.CreateView(audit);
+		}
+		finally
+		{
+			_readerWriter.ExitReadLock();
 		}
+	}
 
-		/// <inheritdoc />
-		protected override void Dispose(bool disposing)
+	/// <inheritdoc />
+	protected override void Dispose(bool disposing)
+	{
+		if (!_disposed)
 		{
-			if (!_disposed)
+			if (disposing)
 			{
-				if (disposing)
-				{
-					_readerWriter?.Dispose();
-				}
-
-				_disposed = true;
+				_readerWriter?.Dispose();
 			}
 
-			base.Dispose(disposing);
+			_disposed = true;
 		}
+
+		base.Dispose(disposing);
 	}
 }
diff --git a/src/Elastic.Transport/Components/NodePool/StaticNodePool.cs b/src/Elastic.Transport/Components/NodePool/StaticNodePool.cs
index a779526..a631943 100644
--- a/src/Elastic.Transport/Components/NodePool/StaticNodePool.cs
+++ b/src/Elastic.Transport/Components/NodePool/StaticNodePool.cs
@@ -9,206 +9,205 @@
 using Elastic.Transport.Diagnostics.Auditing;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A node pool that disables <see cref="SupportsReseeding"/> which in turn disallows the <see cref="HttpTransport{TConnectionSettings}"/> to enable sniffing to
+/// discover the current cluster's list of active nodes.
+/// <para>Therefore the nodes you supply are the list of known nodes throughout its lifetime, hence static</para>
+/// </summary>
+public class StaticNodePool : NodePool
 {
 	/// <summary>
-	/// A node pool that disables <see cref="SupportsReseeding"/> which in turn disallows the <see cref="ITransport{TConnectionSettings}"/> to enable sniffing to
-	/// discover the current cluster's list of active nodes.
-	/// <para>Therefore the nodes you supply are the list of known nodes throughout its lifetime, hence static</para>
+	/// Everytime <see cref="CreateView"/> is called it picks the initial starting point from this cursor.
+	/// After which it uses a local cursor to commence the enumeration. This makes <see cref="CreateView"/> deterministic
+	/// even when if multiple threads enumerate over multiple lazy collections returned by <see cref="CreateView"/>.
 	/// </summary>
-	public class StaticNodePool : NodePool
-	{
-		/// <summary>
-		/// Everytime <see cref="CreateView"/> is called it picks the initial starting point from this cursor.
-		/// After which it uses a local cursor to commence the enumeration. This makes <see cref="CreateView"/> deterministic
-		/// even when if multiple threads enumerate over multiple lazy collections returned by <see cref="CreateView"/>.
-		/// </summary>
-		protected int GlobalCursor = -1;
+	protected int GlobalCursor = -1;
 
-		private readonly Func<Node, float> _nodeScorer;
+	private readonly Func<Node, float> _nodeScorer;
 
-		/// <inheritdoc cref="StaticNodePool"/>
-		public StaticNodePool(IEnumerable<Uri> uris, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
-			: this(uris.Select(uri => new Node(uri)), randomize, null, dateTimeProvider) { }
+	/// <inheritdoc cref="StaticNodePool"/>
+	public StaticNodePool(IEnumerable<Uri> uris, bool randomize = true, DateTimeProvider dateTimeProvider = null)
+		: this(uris.Select(uri => new Node(uri)), randomize, null, dateTimeProvider) { }
 
-		/// <inheritdoc cref="StaticNodePool"/>
-		public StaticNodePool(IEnumerable<Node> nodes, bool randomize = true, IDateTimeProvider dateTimeProvider = null)
-			: this(nodes, randomize, null, dateTimeProvider) { }
+	/// <inheritdoc cref="StaticNodePool"/>
+	public StaticNodePool(IEnumerable<Node> nodes, bool randomize = true, DateTimeProvider dateTimeProvider = null)
+		: this(nodes, randomize, null, dateTimeProvider) { }
 
-		/// <inheritdoc cref="StaticNodePool"/>
-		protected StaticNodePool(IEnumerable<Node> nodes, bool randomize, int? randomizeSeed = null, IDateTimeProvider dateTimeProvider = null)
-		{
-			Randomize = randomize;
-			Random = !randomize || !randomizeSeed.HasValue
-				? new Random()
-				: new Random(randomizeSeed.Value);
+	/// <inheritdoc cref="StaticNodePool"/>
+	protected StaticNodePool(IEnumerable<Node> nodes, bool randomize, int? randomizeSeed = null, DateTimeProvider dateTimeProvider = null)
+	{
+		Randomize = randomize;
+		Random = !randomize || !randomizeSeed.HasValue
+			? new Random()
+			: new Random(randomizeSeed.Value);
 
-			Initialize(nodes, dateTimeProvider);
-		}
+		Initialize(nodes, dateTimeProvider);
+	}
 
-		//this constructor is protected because nodeScorer only makes sense on subclasses that support reseeding otherwise just manually sort `nodes` before instantiating.
-		/// <inheritdoc cref="StaticNodePool"/>
-		protected StaticNodePool(IEnumerable<Node> nodes, Func<Node, float> nodeScorer = null, IDateTimeProvider dateTimeProvider = null)
-		{
-			_nodeScorer = nodeScorer;
-			Initialize(nodes, dateTimeProvider);
-		}
+	//this constructor is protected because nodeScorer only makes sense on subclasses that support reseeding otherwise just manually sort `nodes` before instantiating.
+	/// <inheritdoc cref="StaticNodePool"/>
+	protected StaticNodePool(IEnumerable<Node> nodes, Func<Node, float> nodeScorer = null, DateTimeProvider dateTimeProvider = null)
+	{
+		_nodeScorer = nodeScorer;
+		Initialize(nodes, dateTimeProvider);
+	}
 
-		private void Initialize(IEnumerable<Node> nodes, IDateTimeProvider dateTimeProvider)
-		{
-			var nodesProvided = nodes?.ToList() ?? throw new ArgumentNullException(nameof(nodes));
-			nodesProvided.ThrowIfEmpty(nameof(nodes));
-			DateTimeProvider = dateTimeProvider ?? Elastic.Transport.DateTimeProvider.Default;
+	private void Initialize(IEnumerable<Node> nodes, DateTimeProvider dateTimeProvider)
+	{
+		var nodesProvided = nodes?.ToList() ?? throw new ArgumentNullException(nameof(nodes));
+		nodesProvided.ThrowIfEmpty(nameof(nodes));
+		DateTimeProvider = dateTimeProvider ?? Elastic.Transport.DefaultDateTimeProvider.Default;
 
-			string scheme = null;
-			foreach (var node in nodesProvided)
+		string scheme = null;
+		foreach (var node in nodesProvided)
+		{
+			if (scheme == null)
 			{
-				if (scheme == null)
-				{
-					scheme = node.Uri.Scheme;
-					UsingSsl = scheme == "https";
-				}
-				else if (scheme != node.Uri.Scheme)
-					throw new ArgumentException("Trying to instantiate a connection pool with mixed URI Schemes");
+				scheme = node.Uri.Scheme;
+				UsingSsl = scheme == "https";
 			}
-
-			InternalNodes = SortNodes(nodesProvided)
-				.DistinctByCustom(n => n.Uri)
-				.ToList();
-			LastUpdate = DateTimeProvider.Now();
+			else if (scheme != node.Uri.Scheme)
+				throw new ArgumentException("Trying to instantiate a connection pool with mixed URI Schemes");
 		}
 
-		/// <inheritdoc />
-		public override DateTime LastUpdate { get; protected set; }
+		InternalNodes = SortNodes(nodesProvided)
+			.DistinctByCustom(n => n.Uri)
+			.ToList();
+		LastUpdate = DateTimeProvider.Now();
+	}
 
-		/// <inheritdoc />
-		public override int MaxRetries => InternalNodes.Count - 1;
+	/// <inheritdoc />
+	public override DateTime LastUpdate { get; protected set; }
 
-		/// <inheritdoc />
-		public override IReadOnlyCollection<Node> Nodes => InternalNodes;
+	/// <inheritdoc />
+	public override int MaxRetries => InternalNodes.Count - 1;
 
-		/// <inheritdoc />
-		public override bool SupportsPinging => true;
+	/// <inheritdoc />
+	public override IReadOnlyCollection<Node> Nodes => InternalNodes;
 
-		/// <inheritdoc />
-		public override bool SupportsReseeding => false;
+	/// <inheritdoc />
+	public override bool SupportsPinging => true;
 
-		/// <inheritdoc />
-		public override bool UsingSsl { get; protected set; }
+	/// <inheritdoc />
+	public override bool SupportsReseeding => false;
 
-		/// <summary>
-		/// A window into <see cref="InternalNodes"/> that only selects the nodes considered alive at the time of calling
-		/// this property. Taking into account <see cref="IDateTimeProvider.Now"/> and <see cref="Node.DeadUntil"/>
-		/// </summary>
-		protected IReadOnlyList<Node> AliveNodes
-		{
-			get
-			{
-				var now = DateTimeProvider.Now();
-				return InternalNodes
-					.Where(n => n.IsAlive || n.DeadUntil <= now)
-					.ToList();
-			}
-		}
+	/// <inheritdoc />
+	public override bool UsingSsl { get; protected set; }
 
-		/// <inheritdoc cref="IDateTimeProvider"/>>
-		protected IDateTimeProvider DateTimeProvider { get; private set; }
-
-		/// <summary>
-		/// The list of nodes we are operating over. This is protected so that subclasses that DO implement <see cref="SupportsReseeding"/>
-		/// can update this list. Its up to subclasses to make this thread safe.
-		/// </summary>
-		protected List<Node> InternalNodes { get; set; }
-
-		/// <summary>
-		/// If <see cref="Randomize"/> is set sub classes that support reseeding will have to use this instance since it might be based of an
-		/// explicit seed passed into the constructor.
-		/// </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		protected Random Random { get; }
-
-		/// <summary> Whether the nodes order should be randomized after sniffing </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		protected bool Randomize { get; }
-
-		/// <summary>
-		/// Creates a view of all the live nodes with changing starting positions that wraps over on each call
-		/// e.g Thread A might get 1,2,3,4,5 and thread B will get 2,3,4,5,1.
-		/// if there are no live nodes yields a different dead node to try once
-		/// </summary>
-		public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null)
+	/// <summary>
+	/// A window into <see cref="InternalNodes"/> that only selects the nodes considered alive at the time of calling
+	/// this property. Taking into account <see cref="DateTimeProvider.Now"/> and <see cref="Node.DeadUntil"/>
+	/// </summary>
+	protected IReadOnlyList<Node> AliveNodes
+	{
+		get
 		{
-			var nodes = AliveNodes;
+			var now = DateTimeProvider.Now();
+			return InternalNodes
+				.Where(n => n.IsAlive || n.DeadUntil <= now)
+				.ToList();
+		}
+	}
 
-			var globalCursor = Interlocked.Increment(ref GlobalCursor);
+	/// <inheritdoc cref="DateTimeProvider"/>>
+	protected DateTimeProvider DateTimeProvider { get; private set; }
 
-			if (nodes.Count == 0)
-			{
-				//could not find a suitable node retrying on first node off globalCursor
-				yield return RetryInternalNodes(globalCursor, audit);
+	/// <summary>
+	/// The list of nodes we are operating over. This is protected so that subclasses that DO implement <see cref="SupportsReseeding"/>
+	/// can update this list. Its up to subclasses to make this thread safe.
+	/// </summary>
+	protected List<Node> InternalNodes { get; set; }
 
-				yield break;
-			}
+	/// <summary>
+	/// If <see cref="Randomize"/> is set sub classes that support reseeding will have to use this instance since it might be based of an
+	/// explicit seed passed into the constructor.
+	/// </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	protected Random Random { get; }
 
-			var localCursor = globalCursor % nodes.Count;
-			foreach (var aliveNode in SelectAliveNodes(localCursor, nodes, audit)) yield return aliveNode;
-		}
+	/// <summary> Whether the nodes order should be randomized after sniffing </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	protected bool Randomize { get; }
 
-		/// <inheritdoc />
-		public override void Reseed(IEnumerable<Node> nodes) { } //ignored
+	/// <summary>
+	/// Creates a view of all the live nodes with changing starting positions that wraps over on each call
+	/// e.g Thread A might get 1,2,3,4,5 and thread B will get 2,3,4,5,1.
+	/// if there are no live nodes yields a different dead node to try once
+	/// </summary>
+	public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null)
+	{
+		var nodes = AliveNodes;
 
+		var globalCursor = Interlocked.Increment(ref GlobalCursor);
 
-		/// <summary>
-		/// If no active nodes are found this method can be used by subclasses to reactivate the next node based on
-		/// <paramref name="globalCursor"/>
-		/// </summary>
-		/// <param name="globalCursor"></param>
-		/// <param name="audit">Trace action to document the fact all nodes were dead and were resurrecting one at random</param>
-		protected Node RetryInternalNodes(int globalCursor, Action<AuditEvent, Node> audit = null)
+		if (nodes.Count == 0)
 		{
-			audit?.Invoke(AuditEvent.AllNodesDead, null);
-			var node = InternalNodes[globalCursor % InternalNodes.Count];
-			node.IsResurrected = true;
-			audit?.Invoke(AuditEvent.Resurrection, node);
+			//could not find a suitable node retrying on first node off globalCursor
+			yield return RetryInternalNodes(globalCursor, audit);
 
-			return node;
+			yield break;
 		}
 
-		/// <summary>
-		/// Lazy enumerate <paramref name="aliveNodes"/> based on the local <paramref name="cursor"/>. Enumeration will start from <paramref name="cursor"/>
-		/// and loop around the end and stop before hitting <paramref name="cursor"/> again. This ensures all nodes are attempted.
-		/// </summary>
-		/// <param name="cursor">The starting point into <paramref name="aliveNodes"/> from wich to start.</param>
-		/// <param name="aliveNodes"></param>
-		/// <param name="audit">Trace action to notify if a resurrection occured</param>
-		protected static IEnumerable<Node> SelectAliveNodes(int cursor, IReadOnlyList<Node> aliveNodes, Action<AuditEvent, Node> audit = null)
+		var localCursor = globalCursor % nodes.Count;
+		foreach (var aliveNode in SelectAliveNodes(localCursor, nodes, audit)) yield return aliveNode;
+	}
+
+	/// <inheritdoc />
+	public override void Reseed(IEnumerable<Node> nodes) { } //ignored
+
+
+	/// <summary>
+	/// If no active nodes are found this method can be used by subclasses to reactivate the next node based on
+	/// <paramref name="globalCursor"/>
+	/// </summary>
+	/// <param name="globalCursor"></param>
+	/// <param name="audit">Trace action to document the fact all nodes were dead and were resurrecting one at random</param>
+	protected Node RetryInternalNodes(int globalCursor, Action<AuditEvent, Node> audit = null)
+	{
+		audit?.Invoke(AuditEvent.AllNodesDead, null);
+		var node = InternalNodes[globalCursor % InternalNodes.Count];
+		node.IsResurrected = true;
+		audit?.Invoke(AuditEvent.Resurrection, node);
+
+		return node;
+	}
+
+	/// <summary>
+	/// Lazy enumerate <paramref name="aliveNodes"/> based on the local <paramref name="cursor"/>. Enumeration will start from <paramref name="cursor"/>
+	/// and loop around the end and stop before hitting <paramref name="cursor"/> again. This ensures all nodes are attempted.
+	/// </summary>
+	/// <param name="cursor">The starting point into <paramref name="aliveNodes"/> from wich to start.</param>
+	/// <param name="aliveNodes"></param>
+	/// <param name="audit">Trace action to notify if a resurrection occured</param>
+	protected static IEnumerable<Node> SelectAliveNodes(int cursor, IReadOnlyList<Node> aliveNodes, Action<AuditEvent, Node> audit = null)
+	{
+		// ReSharper disable once ForCanBeConvertedToForeach
+		for (var attempts = 0; attempts < aliveNodes.Count; attempts++)
 		{
-			// ReSharper disable once ForCanBeConvertedToForeach
-			for (var attempts = 0; attempts < aliveNodes.Count; attempts++)
+			var node = aliveNodes[cursor];
+			cursor = (cursor + 1) % aliveNodes.Count;
+			//if this node is not alive or no longer dead mark it as resurrected
+			if (!node.IsAlive)
 			{
-				var node = aliveNodes[cursor];
-				cursor = (cursor + 1) % aliveNodes.Count;
-				//if this node is not alive or no longer dead mark it as resurrected
-				if (!node.IsAlive)
-				{
-					audit?.Invoke(AuditEvent.Resurrection, node);
-					node.IsResurrected = true;
-				}
-
-				yield return node;
+				audit?.Invoke(AuditEvent.Resurrection, node);
+				node.IsResurrected = true;
 			}
-		}
 
-		/// <summary>
-		/// Provides the default sort order for <see cref="CreateView"/> this takes into account whether a subclass injected a custom <see cref="Node"/> comparer
-		/// and if not whether <see cref="Randomize"/> is set
-		/// </summary>
-		protected IOrderedEnumerable<Node> SortNodes(IEnumerable<Node> nodes) =>
-			_nodeScorer != null
-				? nodes.OrderByDescending(_nodeScorer)
-				: nodes.OrderBy(n => Randomize ? Random.Next() : 1);
-
-		/// <inheritdoc />
-		protected override void Dispose(bool disposing) => base.Dispose(disposing);
+			yield return node;
+		}
 	}
+
+	/// <summary>
+	/// Provides the default sort order for <see cref="CreateView"/> this takes into account whether a subclass injected a custom <see cref="Node"/> comparer
+	/// and if not whether <see cref="Randomize"/> is set
+	/// </summary>
+	protected IOrderedEnumerable<Node> SortNodes(IEnumerable<Node> nodes) =>
+		_nodeScorer != null
+			? nodes.OrderByDescending(_nodeScorer)
+			: nodes.OrderBy(n => Randomize ? Random.Next() : 1);
+
+	/// <inheritdoc />
+	protected override void Dispose(bool disposing) => base.Dispose(disposing);
 }
diff --git a/src/Elastic.Transport/Components/NodePool/StickyNodePool.cs b/src/Elastic.Transport/Components/NodePool/StickyNodePool.cs
index 1242c00..fab319e 100644
--- a/src/Elastic.Transport/Components/NodePool/StickyNodePool.cs
+++ b/src/Elastic.Transport/Components/NodePool/StickyNodePool.cs
@@ -7,48 +7,47 @@
 using System.Threading;
 using Elastic.Transport.Diagnostics.Auditing;
 
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// A connection pool implementation that does not support reseeding and stays on the first <see cref="Node"/> reporting true for <see cref="Node.IsAlive"/>.
-	/// This is great if for instance you have multiple proxies that you can fallback on allowing you to seed the proxies in order of preference.
-	/// </summary>
-	public sealed class StickyNodePool : StaticNodePool
-	{
-		/// <inheritdoc cref="StickyNodePool"/>
-		public StickyNodePool(IEnumerable<Uri> uris, IDateTimeProvider dateTimeProvider = null)
-			: base(uris, false, dateTimeProvider) { }
-
-		/// <inheritdoc cref="StickyNodePool"/>
-		public StickyNodePool(IEnumerable<Node> nodes, IDateTimeProvider dateTimeProvider = null)
-			: base(nodes, false, dateTimeProvider) { }
+namespace Elastic.Transport;
 
-		/// <inheritdoc cref="StaticNodePool.CreateView"/>
-		public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null)
-		{
-			var nodes = AliveNodes;
+/// <summary>
+/// A connection pool implementation that does not support reseeding and stays on the first <see cref="Node"/> reporting true for <see cref="Node.IsAlive"/>.
+/// This is great if for instance you have multiple proxies that you can fallback on allowing you to seed the proxies in order of preference.
+/// </summary>
+public sealed class StickyNodePool : StaticNodePool
+{
+	/// <inheritdoc cref="StickyNodePool"/>
+	public StickyNodePool(IEnumerable<Uri> uris, DateTimeProvider dateTimeProvider = null)
+		: base(uris, false, dateTimeProvider) { }
 
-			if (nodes.Count == 0)
-			{
-				var globalCursor = Interlocked.Increment(ref GlobalCursor);
+	/// <inheritdoc cref="StickyNodePool"/>
+	public StickyNodePool(IEnumerable<Node> nodes, DateTimeProvider dateTimeProvider = null)
+		: base(nodes, false, dateTimeProvider) { }
 
-				//could not find a suitable node retrying on first node off globalCursor
-				yield return RetryInternalNodes(globalCursor, audit);
+	/// <inheritdoc cref="StaticNodePool.CreateView"/>
+	public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null)
+	{
+		var nodes = AliveNodes;
 
-				yield break;
-			}
+		if (nodes.Count == 0)
+		{
+			var globalCursor = Interlocked.Increment(ref GlobalCursor);
 
-			// If the cursor is greater than the default then it's been
-			// set already but we now have a live node so we should reset it
-			if (GlobalCursor > -1)
-				Interlocked.Exchange(ref GlobalCursor, -1);
+			//could not find a suitable node retrying on first node off globalCursor
+			yield return RetryInternalNodes(globalCursor, audit);
 
-			var localCursor = 0;
-			foreach (var aliveNode in SelectAliveNodes(localCursor, nodes, audit))
-				yield return aliveNode;
+			yield break;
 		}
 
-		/// <inheritdoc cref="StaticNodePool.Reseed"/>
-		public override void Reseed(IEnumerable<Node> nodes) { }
+		// If the cursor is greater than the default then it's been
+		// set already but we now have a live node so we should reset it
+		if (GlobalCursor > -1)
+			Interlocked.Exchange(ref GlobalCursor, -1);
+
+		var localCursor = 0;
+		foreach (var aliveNode in SelectAliveNodes(localCursor, nodes, audit))
+			yield return aliveNode;
 	}
+
+	/// <inheritdoc cref="StaticNodePool.Reseed"/>
+	public override void Reseed(IEnumerable<Node> nodes) { }
 }
diff --git a/src/Elastic.Transport/Components/NodePool/StickySniffingNodePool.cs b/src/Elastic.Transport/Components/NodePool/StickySniffingNodePool.cs
index baca685..e4344f4 100644
--- a/src/Elastic.Transport/Components/NodePool/StickySniffingNodePool.cs
+++ b/src/Elastic.Transport/Components/NodePool/StickySniffingNodePool.cs
@@ -8,54 +8,53 @@
 using System.Threading;
 using Elastic.Transport.Diagnostics.Auditing;
 
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// A connection pool implementation that supports reseeding but stays on the first <see cref="Node"/> reporting true for <see cref="Node.IsAlive"/>.
-	/// This is great if for instance you have multiple proxies that you can fallback on allowing you to seed the proxies in order of preference.
-	/// </summary>
-	public sealed class StickySniffingNodePool : SniffingNodePool
-	{
-		/// <inheritdoc cref="StickySniffingNodePool"/>
-		public StickySniffingNodePool(IEnumerable<Uri> uris, Func<Node, float> nodeScorer, IDateTimeProvider dateTimeProvider = null)
-			: base(uris.Select(uri => new Node(uri)), nodeScorer ?? DefaultNodeScore, dateTimeProvider) { }
-
-		/// <inheritdoc cref="StickySniffingNodePool"/>
-		public StickySniffingNodePool(IEnumerable<Node> nodes, Func<Node, float> nodeScorer, IDateTimeProvider dateTimeProvider = null)
-			: base(nodes, nodeScorer ?? DefaultNodeScore, dateTimeProvider) { }
+namespace Elastic.Transport;
 
-		/// <inheritdoc cref="NodePool.SupportsPinging"/>
-		public override bool SupportsPinging => true;
+/// <summary>
+/// A connection pool implementation that supports reseeding but stays on the first <see cref="Node"/> reporting true for <see cref="Node.IsAlive"/>.
+/// This is great if for instance you have multiple proxies that you can fallback on allowing you to seed the proxies in order of preference.
+/// </summary>
+public sealed class StickySniffingNodePool : SniffingNodePool
+{
+	/// <inheritdoc cref="StickySniffingNodePool"/>
+	public StickySniffingNodePool(IEnumerable<Uri> uris, Func<Node, float> nodeScorer, DateTimeProvider dateTimeProvider = null)
+		: base(uris.Select(uri => new Node(uri)), nodeScorer ?? DefaultNodeScore, dateTimeProvider) { }
 
-		/// <inheritdoc cref="NodePool.SupportsReseeding"/>
-		public override bool SupportsReseeding => true;
+	/// <inheritdoc cref="StickySniffingNodePool"/>
+	public StickySniffingNodePool(IEnumerable<Node> nodes, Func<Node, float> nodeScorer, DateTimeProvider dateTimeProvider = null)
+		: base(nodes, nodeScorer ?? DefaultNodeScore, dateTimeProvider) { }
 
-		/// <inheritdoc cref="NodePool.CreateView"/>
-		public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null)
-		{
-			var nodes = AliveNodes;
+	/// <inheritdoc cref="NodePool.SupportsPinging"/>
+	public override bool SupportsPinging => true;
 
-			if (nodes.Count == 0)
-			{
-				var globalCursor = Interlocked.Increment(ref GlobalCursor);
+	/// <inheritdoc cref="NodePool.SupportsReseeding"/>
+	public override bool SupportsReseeding => true;
 
-				//could not find a suitable node retrying on first node off globalCursor
-				yield return RetryInternalNodes(globalCursor, audit);
+	/// <inheritdoc cref="NodePool.CreateView"/>
+	public override IEnumerable<Node> CreateView(Action<AuditEvent, Node> audit = null)
+	{
+		var nodes = AliveNodes;
 
-				yield break;
-			}
+		if (nodes.Count == 0)
+		{
+			var globalCursor = Interlocked.Increment(ref GlobalCursor);
 
-			// If the cursor is greater than the default then it's been
-			// set already but we now have a live node so we should reset it
-			if (GlobalCursor > -1)
-				Interlocked.Exchange(ref GlobalCursor, -1);
+			//could not find a suitable node retrying on first node off globalCursor
+			yield return RetryInternalNodes(globalCursor, audit);
 
-			var localCursor = 0;
-			foreach (var aliveNode in SelectAliveNodes(localCursor, nodes, audit))
-				yield return aliveNode;
+			yield break;
 		}
 
-		/// <summary> Allows subclasses to hook into the parents dispose </summary>
-		private static float DefaultNodeScore(Node node) => 0f;
+		// If the cursor is greater than the default then it's been
+		// set already but we now have a live node so we should reset it
+		if (GlobalCursor > -1)
+			Interlocked.Exchange(ref GlobalCursor, -1);
+
+		var localCursor = 0;
+		foreach (var aliveNode in SelectAliveNodes(localCursor, nodes, audit))
+			yield return aliveNode;
 	}
+
+	/// <summary> Allows subclasses to hook into the parents dispose </summary>
+	private static float DefaultNodeScore(Node node) => 0f;
 }
diff --git a/src/Elastic.Transport/Components/Pipeline/DefaultRequestPipeline.cs b/src/Elastic.Transport/Components/Pipeline/DefaultRequestPipeline.cs
new file mode 100644
index 0000000..ef053f3
--- /dev/null
+++ b/src/Elastic.Transport/Components/Pipeline/DefaultRequestPipeline.cs
@@ -0,0 +1,612 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Elastic.Transport.Diagnostics;
+using Elastic.Transport.Diagnostics.Auditing;
+using Elastic.Transport.Extensions;
+using Elastic.Transport.Products;
+using static Elastic.Transport.Diagnostics.Auditing.AuditEvent;
+
+//#if NETSTANDARD2_0 || NETSTANDARD2_1
+//using System.Threading.Tasks.Extensions;
+//#endif
+
+namespace Elastic.Transport;
+
+/// <inheritdoc cref="RequestPipeline" />
+public class DefaultRequestPipeline<TConfiguration> : RequestPipeline
+	where TConfiguration : class, ITransportConfiguration
+{
+	private readonly TransportClient _transportClient;
+	private readonly NodePool _nodePool;
+	private readonly DateTimeProvider _dateTimeProvider;
+	private readonly MemoryStreamFactory _memoryStreamFactory;
+	private readonly Func<Node, bool> _nodePredicate;
+	private readonly ProductRegistration _productRegistration;
+	private readonly TConfiguration _settings;
+	private readonly ResponseBuilder _responseBuilder;
+
+	private RequestConfiguration _pingAndSniffRequestConfiguration;		
+
+	/// <inheritdoc cref="RequestPipeline" />
+	internal DefaultRequestPipeline(
+		TConfiguration configurationValues,
+		DateTimeProvider dateTimeProvider,
+		MemoryStreamFactory memoryStreamFactory,
+		RequestParameters requestParameters
+	)
+	{
+		_settings = configurationValues;
+		_nodePool = _settings.NodePool;
+		_transportClient = _settings.Connection;
+		_dateTimeProvider = dateTimeProvider;
+		_memoryStreamFactory = memoryStreamFactory;
+		_productRegistration = configurationValues.ProductRegistration;
+		_responseBuilder = _productRegistration.ResponseBuilder;
+		_nodePredicate = _settings.NodePredicate ?? _productRegistration.NodePredicate;
+		RequestConfiguration = requestParameters?.RequestConfiguration;
+		StartedOn = dateTimeProvider.Now();
+	}
+
+	/// <inheritdoc cref="RequestPipeline.AuditTrail" />
+	public override List<Audit> AuditTrail { get; } = new();
+
+	private RequestConfiguration PingAndSniffRequestConfiguration
+	{
+		// Lazily loaded when first required, since not all node pools and configurations support pinging and sniffing.
+		// This avoids allocating 192B per request for those which do not need to ping or sniff.
+		get
+		{
+			if (_pingAndSniffRequestConfiguration is not null) return _pingAndSniffRequestConfiguration;
+
+			_pingAndSniffRequestConfiguration = new RequestConfiguration
+			{
+				PingTimeout = PingTimeout,
+				RequestTimeout = PingTimeout,
+				AuthenticationHeader = _settings.Authentication,
+				EnableHttpPipelining = RequestConfiguration?.EnableHttpPipelining ?? _settings.HttpPipeliningEnabled,
+				ForceNode = RequestConfiguration?.ForceNode
+			};
+
+			return _pingAndSniffRequestConfiguration;
+		}
+	}
+
+	//TODO xmldocs
+#pragma warning disable 1591
+	public bool DepletedRetries => Retried >= MaxRetries + 1 || IsTakingTooLong;
+
+	public override bool FirstPoolUsageNeedsSniffing =>
+		!RequestDisabledSniff
+		&& _nodePool.SupportsReseeding && _settings.SniffsOnStartup && !_nodePool.SniffedOnStartup;
+
+	public override bool IsTakingTooLong
+	{
+		get
+		{
+			var timeout = _settings.MaxRetryTimeout.GetValueOrDefault(RequestTimeout);
+			var now = _dateTimeProvider.Now();
+
+			//we apply a soft margin so that if a request timesout at 59 seconds when the maximum is 60 we also abort.
+			var margin = timeout.TotalMilliseconds / 100.0 * 98;
+			var marginTimeSpan = TimeSpan.FromMilliseconds(margin);
+			var timespanCall = now - StartedOn;
+			var tookToLong = timespanCall >= marginTimeSpan;
+			return tookToLong;
+		}
+	}
+
+	public override int MaxRetries =>
+		RequestConfiguration?.ForceNode != null
+			? 0
+			: Math.Min(RequestConfiguration?.MaxRetries ?? _settings.MaxRetries.GetValueOrDefault(int.MaxValue), _nodePool.MaxRetries);
+
+	public bool Refresh { get; private set; }
+
+	public int Retried { get; private set; }
+
+	public IEnumerable<Node> SniffNodes => _nodePool
+		.CreateView(LazyAuditable)
+		.ToList()
+		.OrderBy(n => _productRegistration.SniffOrder(n));
+
+	public override bool SniffsOnConnectionFailure =>
+		!RequestDisabledSniff
+		&& _nodePool.SupportsReseeding && _settings.SniffsOnConnectionFault;
+
+	public override bool SniffsOnStaleCluster =>
+		!RequestDisabledSniff
+		&& _nodePool.SupportsReseeding && _settings.SniffInformationLifeSpan.HasValue;
+
+	public override bool StaleClusterState
+	{
+		get
+		{
+			if (!SniffsOnStaleCluster) return false;
+
+			// ReSharper disable once PossibleInvalidOperationException
+			// already checked by SniffsOnStaleCluster
+			var sniffLifeSpan = _settings.SniffInformationLifeSpan.Value;
+
+			var now = _dateTimeProvider.Now();
+			var lastSniff = _nodePool.LastUpdate;
+
+			return sniffLifeSpan < now - lastSniff;
+		}
+	}
+
+	public override DateTime StartedOn { get; }
+
+	private TimeSpan PingTimeout =>
+		RequestConfiguration?.PingTimeout
+		?? _settings.PingTimeout
+		?? (_nodePool.UsingSsl ? TransportConfiguration.DefaultPingTimeoutOnSsl : TransportConfiguration.DefaultPingTimeout);
+
+	private IRequestConfiguration RequestConfiguration { get; }
+
+	private bool RequestDisabledSniff => RequestConfiguration != null && (RequestConfiguration.DisableSniff ?? false);
+
+	private TimeSpan RequestTimeout => RequestConfiguration?.RequestTimeout ?? _settings.RequestTimeout;
+
+	public override void AuditCancellationRequested() => Audit(CancellationRequested).Dispose();
+
+	public override void BadResponse<TResponse>(ref TResponse response, ApiCallDetails callDetails, RequestData data, TransportException exception)
+	{
+		if (response == null)
+		{
+			//make sure we copy over the error body in case we disabled direct streaming.
+			var s = callDetails?.ResponseBodyInBytes == null ? Stream.Null : _memoryStreamFactory.Create(callDetails.ResponseBodyInBytes);
+			var m = callDetails?.ResponseMimeType ?? RequestData.MimeType;
+			response = _responseBuilder.ToResponse<TResponse>(data, exception, callDetails?.HttpStatusCode, null, s, m, callDetails?.ResponseBodyInBytes?.Length ?? -1, null, null);
+		}
+
+		if (response.ApiCallDetails is ApiCallDetails apiCallDetails)
+			apiCallDetails.AuditTrail = AuditTrail;
+	}
+
+	public override TResponse CallProductEndpoint<TResponse>(RequestData requestData)
+	{
+		using (var audit = Audit(HealthyResponse, requestData.Node))
+		using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, ApiCallDetails>(
+			DiagnosticSources.RequestPipeline.CallProductEndpoint, requestData))
+		{
+			audit.Path = requestData.PathAndQuery;
+			try
+			{
+				var response = _transportClient.Request<TResponse>(requestData);
+				d.EndState = response.ApiCallDetails;
+
+				if (response.ApiCallDetails is ApiCallDetails apiCallDetails)
+					apiCallDetails.AuditTrail = AuditTrail;
+
+				ThrowBadAuthPipelineExceptionWhenNeeded(response.ApiCallDetails, response);
+				if (!response.ApiCallDetails.Success) audit.Event = requestData.OnFailureAuditEvent;
+				return response;
+			}
+			catch (Exception e)
+			{
+				audit.Event = requestData.OnFailureAuditEvent;
+				audit.Exception = e;
+				throw;
+			}
+		}
+	}
+
+	public override async Task<TResponse> CallProductEndpointAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken)
+	{
+		using (var audit = Audit(HealthyResponse, requestData.Node))
+		using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, ApiCallDetails>(
+			DiagnosticSources.RequestPipeline.CallProductEndpoint, requestData))
+		{
+			audit.Path = requestData.PathAndQuery;
+			try
+			{
+				var response = await _transportClient.RequestAsync<TResponse>(requestData, cancellationToken).ConfigureAwait(false);
+				d.EndState = response.ApiCallDetails;
+
+				if (response.ApiCallDetails is ApiCallDetails apiCallDetails)
+					apiCallDetails.AuditTrail = AuditTrail;
+
+				ThrowBadAuthPipelineExceptionWhenNeeded(response.ApiCallDetails, response);
+				if (!response.ApiCallDetails.Success) audit.Event = requestData.OnFailureAuditEvent;
+				return response;
+			}
+			catch (Exception e)
+			{
+				audit.Event = requestData.OnFailureAuditEvent;
+				audit.Exception = e;
+				throw;
+			}
+		}
+	}
+
+	public override TransportException CreateClientException<TResponse>(
+		TResponse response, ApiCallDetails callDetails, RequestData data, List<PipelineException> pipelineExceptions)
+	{
+		if (callDetails?.Success ?? false) return null;
+
+		var pipelineFailure = data.OnFailurePipelineFailure;
+		var innerException = callDetails?.OriginalException;
+		if (pipelineExceptions.HasAny(out var exs))
+		{
+			pipelineFailure = exs.Last().FailureReason;
+			innerException = exs.AsAggregateOrFirst();
+		}
+
+		var statusCode = callDetails?.HttpStatusCode != null ? callDetails.HttpStatusCode.Value.ToString() : "unknown";
+		var resource = callDetails == null
+			? "unknown resource"
+			: $"Status code {statusCode} from: {callDetails.HttpMethod} {callDetails.Uri.PathAndQuery}";
+
+		var exceptionMessage = innerException?.Message ?? "Request failed to execute";
+
+		if (IsTakingTooLong)
+		{
+			pipelineFailure = PipelineFailure.MaxTimeoutReached;
+			Audit(MaxTimeoutReached);
+			exceptionMessage = "Maximum timeout reached while retrying request";
+		}
+		else if (Retried >= MaxRetries && MaxRetries > 0)
+		{
+			pipelineFailure = PipelineFailure.MaxRetriesReached;
+			Audit(MaxRetriesReached);
+			exceptionMessage = "Maximum number of retries reached";
+
+			var now = _dateTimeProvider.Now();
+			var activeNodes = _nodePool.Nodes.Count(n => n.IsAlive || n.DeadUntil <= now);
+			if (Retried >= activeNodes)
+			{
+				Audit(FailedOverAllNodes);
+				exceptionMessage += ", failed over to all the known alive nodes before failing";
+			}
+		}
+
+		exceptionMessage += !exceptionMessage.EndsWith(".", StringComparison.Ordinal) ? $". Call: {resource}" : $" Call: {resource}";
+		if (response != null && _productRegistration.TryGetServerErrorReason(response, out var reason))
+			exceptionMessage += $". ServerError: {reason}";
+
+		var clientException = new TransportException(pipelineFailure, exceptionMessage, innerException)
+		{
+			Request = data, ApiCallDetails = callDetails, AuditTrail = AuditTrail
+		};
+
+		return clientException;
+	}
+
+	public override void FirstPoolUsage(SemaphoreSlim semaphore)
+	{
+		if (!FirstPoolUsageNeedsSniffing) return;
+
+		if (!semaphore.Wait(_settings.RequestTimeout))
+		{
+			if (FirstPoolUsageNeedsSniffing)
+				throw new PipelineException(PipelineFailure.CouldNotStartSniffOnStartup, null);
+
+			return;
+		}
+
+		if (!FirstPoolUsageNeedsSniffing)
+		{
+			semaphore.Release();
+			return;
+		}
+
+		try
+		{
+			using (Audit(SniffOnStartup))
+			{
+				Sniff();
+				_nodePool.MarkAsSniffed();
+			}
+		}
+		finally
+		{
+			semaphore.Release();
+		}
+	}
+
+	public override async Task FirstPoolUsageAsync(SemaphoreSlim semaphore, CancellationToken cancellationToken)
+	{
+		if (!FirstPoolUsageNeedsSniffing) return;
+
+		// TODO cancellationToken could throw here and will bubble out as OperationCancelledException
+		// everywhere else it would bubble out wrapped in a `UnexpectedTransportException`
+		var success = await semaphore.WaitAsync(_settings.RequestTimeout, cancellationToken).ConfigureAwait(false);
+		if (!success)
+		{
+			if (FirstPoolUsageNeedsSniffing)
+				throw new PipelineException(PipelineFailure.CouldNotStartSniffOnStartup, null);
+
+			return;
+		}
+
+		if (!FirstPoolUsageNeedsSniffing)
+		{
+			semaphore.Release();
+			return;
+		}
+		try
+		{
+			using (Audit(SniffOnStartup))
+			{
+				await SniffAsync(cancellationToken).ConfigureAwait(false);
+				_nodePool.MarkAsSniffed();
+			}
+		}
+		finally
+		{
+			semaphore.Release();
+		}
+	}
+
+	public override void MarkAlive(Node node) => node.MarkAlive();
+
+	public override void MarkDead(Node node)
+	{
+		var deadUntil = _dateTimeProvider.DeadTime(node.FailedAttempts, _settings.DeadTimeout, _settings.MaxDeadTimeout);
+		node.MarkDead(deadUntil);
+		Retried++;
+	}
+
+	/// <inheritdoc />
+	public override bool TryGetSingleNode(out Node node)
+	{
+		if (_nodePool.Nodes.Count <= 1 && _nodePool.MaxRetries <= _nodePool.Nodes.Count &&
+			!_nodePool.SupportsPinging && !_nodePool.SupportsReseeding)
+		{
+			node = _nodePool.Nodes.FirstOrDefault();
+
+			if (node is not null && _nodePredicate(node)) return true;
+		}
+
+		node = null;
+		return false;
+	}
+
+	public override IEnumerable<Node> NextNode()
+	{
+		if (RequestConfiguration?.ForceNode != null)
+		{
+			yield return new Node(RequestConfiguration.ForceNode);
+
+			yield break;
+		}
+
+		//This for loop allows to break out of the view state machine if we need to
+		//force a refresh (after reseeding node pool). We have a hardcoded limit of only
+		//allowing 100 of these refreshes per call
+		var refreshed = false;
+		for (var i = 0; i < 100; i++)
+		{
+			if (DepletedRetries) yield break;
+
+			foreach (var node in _nodePool.CreateView(LazyAuditable))
+			{
+				if (DepletedRetries) break;
+
+				if (!_nodePredicate(node)) continue;
+
+				yield return node;
+
+				if (!Refresh) continue;
+
+				Refresh = false;
+				refreshed = true;
+				break;
+			}
+			//unless a refresh was requested we will not iterate over more then a single view.
+			//keep in mind refreshes are also still bound to overall maxretry count/timeout.
+			if (!refreshed) break;
+		}
+	}
+
+	public override void Ping(Node node)
+	{
+		if (!_productRegistration.SupportsPing) return;
+		if (PingDisabled(node)) return;
+
+		var pingData = _productRegistration.CreatePingRequestData(node, PingAndSniffRequestConfiguration, _settings, _memoryStreamFactory);
+		using (var audit = Audit(PingSuccess, node))
+		using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, ApiCallDetails>(DiagnosticSources.RequestPipeline.Ping,
+			pingData))
+		{
+			audit.Path = pingData.PathAndQuery;
+			try
+			{
+				var response = _productRegistration.Ping(_transportClient, pingData);
+				d.EndState = response.ApiCallDetails;
+				ThrowBadAuthPipelineExceptionWhenNeeded(response.ApiCallDetails);
+				//ping should not silently accept bad but valid http responses
+				if (!response.ApiCallDetails.Success)
+					throw new PipelineException(pingData.OnFailurePipelineFailure, response.ApiCallDetails.OriginalException) { Response = response };
+			}
+			catch (Exception e)
+			{
+				var response = (e as PipelineException)?.Response;
+				audit.Event = PingFailure;
+				audit.Exception = e;
+				throw new PipelineException(PipelineFailure.PingFailure, e) { Response = response };
+			}
+		}
+	}
+
+	public override async Task PingAsync(Node node, CancellationToken cancellationToken)
+	{
+		if (!_productRegistration.SupportsPing) return;
+		if (PingDisabled(node)) return;
+
+		var pingData = _productRegistration.CreatePingRequestData(node, PingAndSniffRequestConfiguration, _settings, _memoryStreamFactory);
+		using (var audit = Audit(PingSuccess, node))
+		using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, ApiCallDetails>(DiagnosticSources.RequestPipeline.Ping,
+			pingData))
+		{
+			audit.Path = pingData.PathAndQuery;
+			try
+			{
+				var response = await _productRegistration.PingAsync(_transportClient, pingData, cancellationToken).ConfigureAwait(false);
+				d.EndState = response.ApiCallDetails;
+				ThrowBadAuthPipelineExceptionWhenNeeded(response.ApiCallDetails);
+				//ping should not silently accept bad but valid http responses
+				if (!response.ApiCallDetails.Success)
+					throw new PipelineException(pingData.OnFailurePipelineFailure, response.ApiCallDetails.OriginalException) { Response = response };
+			}
+			catch (Exception e)
+			{
+				var response = (e as PipelineException)?.Response;
+				audit.Event = PingFailure;
+				audit.Exception = e;
+				throw new PipelineException(PipelineFailure.PingFailure, e) { Response = response };
+			}
+		}
+	}
+
+	public override void Sniff()
+	{
+		if (!_productRegistration.SupportsSniff) return;
+
+		var exceptions = new List<Exception>();
+		foreach (var node in SniffNodes)
+		{
+			var requestData =
+				_productRegistration.CreateSniffRequestData(node, PingAndSniffRequestConfiguration, _settings, _memoryStreamFactory);
+			using (var audit = Audit(SniffSuccess, node))
+			using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, ApiCallDetails>(DiagnosticSources.RequestPipeline.Sniff,
+				requestData))
+			using (RequestPipelineStatics.DiagnosticSource.Diagnose(DiagnosticSources.RequestPipeline.Sniff, requestData))
+				try
+				{
+					audit.Path = requestData.PathAndQuery;
+					var (response, nodes) = _productRegistration.Sniff(_transportClient, _nodePool.UsingSsl, requestData);
+					d.EndState = response.ApiCallDetails;
+
+					ThrowBadAuthPipelineExceptionWhenNeeded(response.ApiCallDetails);
+					//sniff should not silently accept bad but valid http responses
+					if (!response.ApiCallDetails.Success)
+						throw new PipelineException(requestData.OnFailurePipelineFailure, response.ApiCallDetails.OriginalException) { Response = response };
+
+					_nodePool.Reseed(nodes);
+					Refresh = true;
+					return;
+				}
+				catch (Exception e)
+				{
+					audit.Event = SniffFailure;
+					audit.Exception = e;
+					exceptions.Add(e);
+				}
+		}
+
+		throw new PipelineException(PipelineFailure.SniffFailure, exceptions.AsAggregateOrFirst());
+	}
+
+	public override async Task SniffAsync(CancellationToken cancellationToken)
+	{
+		if (!_productRegistration.SupportsSniff) return;
+
+		var exceptions = new List<Exception>();
+		foreach (var node in SniffNodes)
+		{
+			var requestData =
+				_productRegistration.CreateSniffRequestData(node, PingAndSniffRequestConfiguration, _settings, _memoryStreamFactory);
+			using (var audit = Audit(SniffSuccess, node))
+			using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, ApiCallDetails>(DiagnosticSources.RequestPipeline.Sniff,
+				requestData))
+				try
+				{
+					audit.Path = requestData.PathAndQuery;
+					var (response, nodes) = await _productRegistration
+						.SniffAsync(_transportClient, _nodePool.UsingSsl, requestData, cancellationToken)
+						.ConfigureAwait(false);
+					d.EndState = response.ApiCallDetails;
+
+					ThrowBadAuthPipelineExceptionWhenNeeded(response.ApiCallDetails);
+					//sniff should not silently accept bad but valid http responses
+					if (!response.ApiCallDetails.Success)
+						throw new PipelineException(requestData.OnFailurePipelineFailure, response.ApiCallDetails.OriginalException) { Response = response };
+
+					_nodePool.Reseed(nodes);
+					Refresh = true;
+					return;
+				}
+				catch (Exception e)
+				{
+					audit.Event = SniffFailure;
+					audit.Exception = e;
+					exceptions.Add(e);
+				}
+		}
+
+		throw new PipelineException(PipelineFailure.SniffFailure, exceptions.AsAggregateOrFirst());
+	}
+
+	public override void SniffOnConnectionFailure()
+	{
+		if (!SniffsOnConnectionFailure) return;
+
+		using (Audit(SniffOnFail))
+			Sniff();
+	}
+
+	public override async Task SniffOnConnectionFailureAsync(CancellationToken cancellationToken)
+	{
+		if (!SniffsOnConnectionFailure) return;
+
+		using (Audit(SniffOnFail))
+			await SniffAsync(cancellationToken).ConfigureAwait(false);
+	}
+
+	public override void SniffOnStaleCluster()
+	{
+		if (!StaleClusterState) return;
+
+		using (Audit(AuditEvent.SniffOnStaleCluster))
+		{
+			Sniff();
+			_nodePool.MarkAsSniffed();
+		}
+	}
+
+	public override async Task SniffOnStaleClusterAsync(CancellationToken cancellationToken)
+	{
+		if (!StaleClusterState) return;
+
+		using (Audit(AuditEvent.SniffOnStaleCluster))
+		{
+			await SniffAsync(cancellationToken).ConfigureAwait(false);
+			_nodePool.MarkAsSniffed();
+		}
+	}
+
+	public override void ThrowNoNodesAttempted(RequestData requestData, List<PipelineException> seenExceptions)
+	{
+		var clientException = new TransportException(PipelineFailure.NoNodesAttempted, RequestPipelineStatics.NoNodesAttemptedMessage,
+			(Exception)null);
+		using (Audit(NoNodesAttempted))
+			throw new UnexpectedTransportException(clientException, seenExceptions) { Request = requestData, AuditTrail = AuditTrail };
+	}
+
+	private bool PingDisabled(Node node) =>
+		(RequestConfiguration?.DisablePing).GetValueOrDefault(false)
+		|| _settings.DisablePings || !_nodePool.SupportsPinging || !node.IsResurrected;
+
+	private Auditable Audit(AuditEvent type, Node node = null) => new(type, AuditTrail, _dateTimeProvider, node);
+
+	private static void ThrowBadAuthPipelineExceptionWhenNeeded(ApiCallDetails details, TransportResponse response = null)
+	{
+		if (details?.HttpStatusCode == 401)
+			throw new PipelineException(PipelineFailure.BadAuthentication, details.OriginalException) { Response = response };
+	}
+
+	private void LazyAuditable(AuditEvent e, Node n)
+	{
+		using (new Auditable(e, AuditTrail, _dateTimeProvider, n)) { }
+	}
+}
+#pragma warning restore 1591
diff --git a/src/Elastic.Transport/Components/Pipeline/DefaultResponseBuilder.cs b/src/Elastic.Transport/Components/Pipeline/DefaultResponseBuilder.cs
index 3650564..e097a66 100644
--- a/src/Elastic.Transport/Components/Pipeline/DefaultResponseBuilder.cs
+++ b/src/Elastic.Transport/Components/Pipeline/DefaultResponseBuilder.cs
@@ -14,338 +14,337 @@
 using Elastic.Transport.Diagnostics;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+///     A helper class that deals with handling how a <see cref="Stream" /> is transformed to the requested
+///     <see cref="TransportResponse" /> implementation. This includes handling optionally buffering based on
+///     <see cref="ITransportConfiguration.DisableDirectStreaming" />. And handling short circuiting special responses
+///     such as <see cref="StringResponse" />, <see cref="BytesResponse" /> and <see cref="VoidResponse" />
+/// </summary>
+internal class DefaultResponseBuilder<TError> : ResponseBuilder where TError : ErrorResponse, new()
 {
+	private const int BufferSize = 81920;
+
+	private readonly bool _isEmptyError;
+
+	public DefaultResponseBuilder() => _isEmptyError = typeof(TError) == typeof(EmptyError);
+
+	private static readonly Type[] SpecialTypes =
+	{
+		typeof(StringResponse), typeof(BytesResponse), typeof(VoidResponse), typeof(DynamicResponse)
+	};
+
 	/// <summary>
-	///     A helper class that deals with handling how a <see cref="Stream" /> is transformed to the requested
-	///     <see cref="ITransportResponse" /> implementation. This includes handling optionally buffering based on
-	///     <see cref="ITransportConfiguration.DisableDirectStreaming" />. And handling short circuiting special responses
-	///     such as <see cref="StringResponse" />, <see cref="BytesResponse" /> and <see cref="VoidResponse" />
+	///     Create an instance of <typeparamref name="TResponse" /> from <paramref name="responseStream" />
 	/// </summary>
-	internal class DefaultResponseBuilder<TError> : ResponseBuilder where TError : ErrorResponse, new()
+	public override TResponse ToResponse<TResponse>(
+		RequestData requestData,
+		Exception ex,
+		int? statusCode,
+		Dictionary<string, IEnumerable<string>> headers,
+		Stream responseStream,
+		string mimeType,
+		long contentLength,
+		IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
+		IReadOnlyDictionary<TcpState, int> tcpStats
+	)
 	{
-		private const int BufferSize = 81920;
+		responseStream.ThrowIfNull(nameof(responseStream));
 
-		private readonly bool _isEmptyError;
+		var details = Initialize(requestData, ex, statusCode, headers, mimeType, threadPoolStats, tcpStats);
 
-		public DefaultResponseBuilder() => _isEmptyError = typeof(TError) == typeof(EmptyError);
+		TResponse response = null;
 
-		private static readonly Type[] SpecialTypes =
-		{
-			typeof(StringResponse), typeof(BytesResponse), typeof(VoidResponse), typeof(DynamicResponse)
-		};
+		// Only attempt to set the body if the response may have content
+		if (MayHaveBody(statusCode, requestData.Method, contentLength))
+			response = SetBody<TResponse>(details, requestData, responseStream, mimeType);
+		else
+			responseStream.Dispose();
 
-		/// <summary>
-		///     Create an instance of <typeparamref name="TResponse" /> from <paramref name="responseStream" />
-		/// </summary>
-		public override TResponse ToResponse<TResponse>(
-			RequestData requestData,
-			Exception ex,
-			int? statusCode,
-			Dictionary<string, IEnumerable<string>> headers,
-			Stream responseStream,
-			string mimeType,
-			long contentLength,
-			IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
-			IReadOnlyDictionary<TcpState, int> tcpStats
-		)
-		{
-			responseStream.ThrowIfNull(nameof(responseStream));
+		response ??= new TResponse();
 
-			var details = Initialize(requestData, ex, statusCode, headers, mimeType, threadPoolStats, tcpStats);
+		response.ApiCallDetails = details;
+		return response;
+	}
 
-			TResponse response = null;
+	/// <summary>
+	///     Create an instance of <typeparamref name="TResponse" /> from <paramref name="responseStream" />
+	/// </summary>
+	public override async Task<TResponse> ToResponseAsync<TResponse>(
+		RequestData requestData,
+		Exception ex,
+		int? statusCode,
+		Dictionary<string, IEnumerable<string>> headers,
+		Stream responseStream,
+		string mimeType,
+		long contentLength,
+		IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
+		IReadOnlyDictionary<TcpState, int> tcpStats,
+		CancellationToken cancellationToken = default
+	)
+	{
+		responseStream.ThrowIfNull(nameof(responseStream));
 
-			// Only attempt to set the body if the response may have content
-			if (MayHaveBody(statusCode, requestData.Method, contentLength))
-				response = SetBody<TResponse>(details, requestData, responseStream, mimeType);
-			else
-				responseStream.Dispose();
+		var details = Initialize(requestData, ex, statusCode, headers, mimeType, threadPoolStats, tcpStats);
 
-			response ??= new TResponse();
+		TResponse response = null;
 
-			response.ApiCall = details;
-			return response;
-		}
+		// Only attempt to set the body if the response may have content
+		if (MayHaveBody(statusCode, requestData.Method, contentLength))
+			response = await SetBodyAsync<TResponse>(details, requestData, responseStream, mimeType,
+				cancellationToken).ConfigureAwait(false);
+		else
+			responseStream.Dispose();
 
-		/// <summary>
-		///     Create an instance of <typeparamref name="TResponse" /> from <paramref name="responseStream" />
-		/// </summary>
-		public override async Task<TResponse> ToResponseAsync<TResponse>(
-			RequestData requestData,
-			Exception ex,
-			int? statusCode,
-			Dictionary<string, IEnumerable<string>> headers,
-			Stream responseStream,
-			string mimeType,
-			long contentLength,
-			IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
-			IReadOnlyDictionary<TcpState, int> tcpStats,
-			CancellationToken cancellationToken = default
-		)
-		{
-			responseStream.ThrowIfNull(nameof(responseStream));
+		response ??= new TResponse();
 
-			var details = Initialize(requestData, ex, statusCode, headers, mimeType, threadPoolStats, tcpStats);
+		response.ApiCallDetails = details;
+		return response;
+	}
 
-			TResponse response = null;
+	/// <summary>
+	///     A helper which returns true if the response could potentially have a body.
+	/// </summary>
+	private static bool MayHaveBody(int? statusCode, HttpMethod httpMethod, long contentLength) =>
+		contentLength != 0 && (!statusCode.HasValue || statusCode.Value != 204 && httpMethod != HttpMethod.HEAD);
 
-			// Only attempt to set the body if the response may have content
-			if (MayHaveBody(statusCode, requestData.Method, contentLength))
-				response = await SetBodyAsync<TResponse>(details, requestData, responseStream, mimeType,
-					cancellationToken).ConfigureAwait(false);
+	private static ApiCallDetails Initialize(
+		RequestData requestData, Exception exception, int? statusCode, Dictionary<string, IEnumerable<string>> headers, string mimeType, IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
+		IReadOnlyDictionary<TcpState, int> tcpStats
+	)
+	{
+		var success = false;
+		var allowedStatusCodes = requestData.AllowedStatusCodes;
+		if (statusCode.HasValue)
+		{
+			if (allowedStatusCodes.Contains(-1) || allowedStatusCodes.Contains(statusCode.Value))
+				success = true;
 			else
-				responseStream.Dispose();
-
-			response ??= new TResponse();
-
-			response.ApiCall = details;
-			return response;
+				success = requestData.ConnectionSettings
+					.StatusCodeToResponseSuccess(requestData.Method, statusCode.Value);
 		}
 
-		/// <summary>
-		///     A helper which returns true if the response could potentially have a body.
-		/// </summary>
-		private static bool MayHaveBody(int? statusCode, HttpMethod httpMethod, long contentLength) =>
-			contentLength != 0 && (!statusCode.HasValue || statusCode.Value != 204 && httpMethod != HttpMethod.HEAD);
+		//mimeType can include charset information on .NET full framework
+		if (!string.IsNullOrEmpty(mimeType) && !mimeType.StartsWith(requestData.Accept))
+			success = false;
 
-		private static ApiCallDetails Initialize(
-			RequestData requestData, Exception exception, int? statusCode, Dictionary<string, IEnumerable<string>> headers, string mimeType, IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
-			IReadOnlyDictionary<TcpState, int> tcpStats
-		)
+		var details = new ApiCallDetails
 		{
-			var success = false;
-			var allowedStatusCodes = requestData.AllowedStatusCodes;
-			if (statusCode.HasValue)
-			{
-				if (allowedStatusCodes.Contains(-1) || allowedStatusCodes.Contains(statusCode.Value))
-					success = true;
-				else
-					success = requestData.ConnectionSettings
-						.StatusCodeToResponseSuccess(requestData.Method, statusCode.Value);
-			}
+			Success = success,
+			OriginalException = exception,
+			HttpStatusCode = statusCode,
+			RequestBodyInBytes = requestData.PostData?.WrittenBytes,
+			Uri = requestData.Uri,
+			HttpMethod = requestData.Method,
+			TcpStats = tcpStats,
+			ThreadPoolStats = threadPoolStats,
+			ResponseMimeType = mimeType,
+			TransportConfiguration = requestData.ConnectionSettings
+		};
 
-			//mimeType can include charset information on .NET full framework
-			if (!string.IsNullOrEmpty(mimeType) && !mimeType.StartsWith(requestData.Accept))
-				success = false;
+		if (headers is not null)
+			details.ParsedHeaders = new ReadOnlyDictionary<string, IEnumerable<string>>(headers);
 
-			var details = new ApiCallDetails
-			{
-				Success = success,
-				OriginalException = exception,
-				HttpStatusCode = statusCode,
-				RequestBodyInBytes = requestData.PostData?.WrittenBytes,
-				Uri = requestData.Uri,
-				HttpMethod = requestData.Method,
-				TcpStats = tcpStats,
-				ThreadPoolStats = threadPoolStats,
-				ResponseMimeType = mimeType,
-				TransportConfiguration = requestData.ConnectionSettings
-			};
-
-			if (headers is not null)
-				details.ParsedHeaders = new ReadOnlyDictionary<string, IEnumerable<string>>(headers);
-
-			return details;
-		}
+		return details;
+	}
 
-		private TResponse SetBody<TResponse>(ApiCallDetails details, RequestData requestData,
-			Stream responseStream, string mimeType)
-			where TResponse : class, ITransportResponse, new()
-		{
-			byte[] bytes = null;
+	private TResponse SetBody<TResponse>(ApiCallDetails details, RequestData requestData,
+		Stream responseStream, string mimeType)
+		where TResponse : TransportResponse, new()
+	{
+		byte[] bytes = null;
 
-			var disableDirectStreaming = requestData.PostData?.DisableDirectStreaming ?? requestData.ConnectionSettings.DisableDirectStreaming;
-			var requiresErrorDeserialization = RequiresErrorDeserialization(details, requestData);
+		var disableDirectStreaming = requestData.PostData?.DisableDirectStreaming ?? requestData.ConnectionSettings.DisableDirectStreaming;
+		var requiresErrorDeserialization = RequiresErrorDeserialization(details, requestData);
 
-			if (disableDirectStreaming || NeedsToEagerReadStream<TResponse>() || requiresErrorDeserialization)
-			{
-				var inMemoryStream = requestData.MemoryStreamFactory.Create();
-				responseStream.CopyTo(inMemoryStream, BufferSize);
-				bytes = SwapStreams(ref responseStream, ref inMemoryStream);
-				details.ResponseBodyInBytes = bytes;
-			}
+		if (disableDirectStreaming || NeedsToEagerReadStream<TResponse>() || requiresErrorDeserialization)
+		{
+			var inMemoryStream = requestData.MemoryStreamFactory.Create();
+			responseStream.CopyTo(inMemoryStream, BufferSize);
+			bytes = SwapStreams(ref responseStream, ref inMemoryStream);
+			details.ResponseBodyInBytes = bytes;
+		}
 
-			using (responseStream)
-			{
-				if (SetSpecialTypes<TResponse>(mimeType, bytes, requestData.MemoryStreamFactory, out var r))
-					return r;
+		using (responseStream)
+		{
+			if (SetSpecialTypes<TResponse>(mimeType, bytes, requestData.MemoryStreamFactory, out var r))
+				return r;
 
-				if (details.HttpStatusCode.HasValue &&
-				    requestData.SkipDeserializationForStatusCodes.Contains(details.HttpStatusCode.Value))
-					return null;
+			if (details.HttpStatusCode.HasValue &&
+			    requestData.SkipDeserializationForStatusCodes.Contains(details.HttpStatusCode.Value))
+				return null;
 
-				var serializer = requestData.ConnectionSettings.RequestResponseSerializer;
+			var serializer = requestData.ConnectionSettings.RequestResponseSerializer;
 
-				if (requestData.CustomResponseBuilder != null)
-					return requestData.CustomResponseBuilder.DeserializeResponse(serializer, details, responseStream) as TResponse;
+			if (requestData.CustomResponseBuilder != null)
+				return requestData.CustomResponseBuilder.DeserializeResponse(serializer, details, responseStream) as TResponse;
 
-				// TODO: Handle empty data in a nicer way as throwing exceptions has a cost we'd like to avoid!
-				// ie. check content-length (add to ApiCallDetails)?
-				try
-				{
-					if (requiresErrorDeserialization && TryGetError(details, requestData, responseStream, out var error) && error.HasError())
-					{
-						var response = new TResponse();
-						SetErrorOnResponse(response, error);
-						return response;
-					}
-
-					return mimeType == null || !mimeType.StartsWith(requestData.Accept, StringComparison.Ordinal)
-						? null
-						: serializer.Deserialize<TResponse>(responseStream);
-				}
-				catch (JsonException ex) when (ex.Message.Contains("The input does not contain any JSON tokens"))
+			// TODO: Handle empty data in a nicer way as throwing exceptions has a cost we'd like to avoid!
+			// ie. check content-length (add to ApiCallDetails)?
+			try
+			{
+				if (requiresErrorDeserialization && TryGetError(details, requestData, responseStream, out var error) && error.HasError())
 				{
-					return default;
+					var response = new TResponse();
+					SetErrorOnResponse(response, error);
+					return response;
 				}
-			}
-		}
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="details"></param>
-		/// <param name="requestData"></param>
-		/// <returns></returns>
-		protected virtual bool RequiresErrorDeserialization(ApiCallDetails details, RequestData requestData) => false;
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="apiCallDetails"></param>
-		/// <param name="requestData"></param>
-		/// <param name="responseStream"></param>
-		/// <param name="error"></param>
-		/// <returns></returns>
-		protected virtual bool TryGetError(ApiCallDetails apiCallDetails, RequestData requestData, Stream responseStream, out TError? error)
-		{
-			if (!_isEmptyError)
+				return mimeType == null || !mimeType.StartsWith(requestData.Accept, StringComparison.Ordinal)
+					? null
+					: serializer.Deserialize<TResponse>(responseStream);
+			}
+			catch (JsonException ex) when (ex.Message.Contains("The input does not contain any JSON tokens"))
 			{
-				error = null;
-				return false;
+				return default;
 			}
+		}
+	}
 
-			error = EmptyError.Instance as TError;
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="details"></param>
+	/// <param name="requestData"></param>
+	/// <returns></returns>
+	protected virtual bool RequiresErrorDeserialization(ApiCallDetails details, RequestData requestData) => false;
 
-			return error is not null;
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="apiCallDetails"></param>
+	/// <param name="requestData"></param>
+	/// <param name="responseStream"></param>
+	/// <param name="error"></param>
+	/// <returns></returns>
+	protected virtual bool TryGetError(ApiCallDetails apiCallDetails, RequestData requestData, Stream responseStream, out TError? error)
+	{
+		if (!_isEmptyError)
+		{
+			error = null;
+			return false;
 		}
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <typeparam name="TResponse"></typeparam>
-		/// <param name="response"></param>
-		/// <param name="error"></param>
-		protected virtual void SetErrorOnResponse<TResponse>(TResponse response, TError error) where TResponse : class, ITransportResponse, new() { }
-
-		private async Task<TResponse> SetBodyAsync<TResponse>(
-			ApiCallDetails details, RequestData requestData, Stream responseStream, string mimeType,
-			CancellationToken cancellationToken
-		)
-			where TResponse : class, ITransportResponse, new()
-		{
-			byte[] bytes = null;
-			var disableDirectStreaming = requestData.PostData?.DisableDirectStreaming ?? requestData.ConnectionSettings.DisableDirectStreaming;
-			var requiresErrorDeserialization = RequiresErrorDeserialization(details, requestData);
+		error = EmptyError.Instance as TError;
 
-			if (disableDirectStreaming || NeedsToEagerReadStream<TResponse>() || requiresErrorDeserialization)
-			{
-				var inMemoryStream = requestData.MemoryStreamFactory.Create();
-				await responseStream.CopyToAsync(inMemoryStream, BufferSize, cancellationToken).ConfigureAwait(false);
-				bytes = SwapStreams(ref responseStream, ref inMemoryStream);
-				details.ResponseBodyInBytes = bytes;
-			}
+		return error is not null;
+	}
 
-			using (responseStream)
-			{
-				if (SetSpecialTypes<TResponse>(mimeType, bytes, requestData.MemoryStreamFactory, out var r)) return r;
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <typeparam name="TResponse"></typeparam>
+	/// <param name="response"></param>
+	/// <param name="error"></param>
+	protected virtual void SetErrorOnResponse<TResponse>(TResponse response, TError error) where TResponse : TransportResponse, new() { }
+
+	private async Task<TResponse> SetBodyAsync<TResponse>(
+		ApiCallDetails details, RequestData requestData, Stream responseStream, string mimeType,
+		CancellationToken cancellationToken
+	)
+		where TResponse : TransportResponse, new()
+	{
+		byte[] bytes = null;
+		var disableDirectStreaming = requestData.PostData?.DisableDirectStreaming ?? requestData.ConnectionSettings.DisableDirectStreaming;
+		var requiresErrorDeserialization = RequiresErrorDeserialization(details, requestData);
 
-				if (details.HttpStatusCode.HasValue &&
-				    requestData.SkipDeserializationForStatusCodes.Contains(details.HttpStatusCode.Value))
-					return null;
+		if (disableDirectStreaming || NeedsToEagerReadStream<TResponse>() || requiresErrorDeserialization)
+		{
+			var inMemoryStream = requestData.MemoryStreamFactory.Create();
+			await responseStream.CopyToAsync(inMemoryStream, BufferSize, cancellationToken).ConfigureAwait(false);
+			bytes = SwapStreams(ref responseStream, ref inMemoryStream);
+			details.ResponseBodyInBytes = bytes;
+		}
 
-				var serializer = requestData.ConnectionSettings.RequestResponseSerializer;
+		using (responseStream)
+		{
+			if (SetSpecialTypes<TResponse>(mimeType, bytes, requestData.MemoryStreamFactory, out var r)) return r;
 
-				if (requestData.CustomResponseBuilder != null)
-					return await requestData.CustomResponseBuilder
-						.DeserializeResponseAsync(serializer, details, responseStream, cancellationToken)
-						.ConfigureAwait(false) as TResponse;
+			if (details.HttpStatusCode.HasValue &&
+			    requestData.SkipDeserializationForStatusCodes.Contains(details.HttpStatusCode.Value))
+				return null;
 
-				// TODO: Handle empty data in a nicer way as throwing exceptions has a cost we'd like to avoid!
-				// ie. check content-length (add to ApiCallDetails)?
-				try
-				{
-					if (requiresErrorDeserialization && TryGetError(details, requestData, responseStream, out var error) && error.HasError())
-					{
-						var response = new TResponse();
-						SetErrorOnResponse(response, error);
-						return response;
-					}
-
-					return mimeType == null || !mimeType.StartsWith(requestData.Accept, StringComparison.Ordinal)
-						? default
-						: await serializer
-							.DeserializeAsync<TResponse>(responseStream, cancellationToken)
-							.ConfigureAwait(false);
-				}
-				catch (JsonException ex) when (ex.Message.Contains("The input does not contain any JSON tokens"))
+			var serializer = requestData.ConnectionSettings.RequestResponseSerializer;
+
+			if (requestData.CustomResponseBuilder != null)
+				return await requestData.CustomResponseBuilder
+					.DeserializeResponseAsync(serializer, details, responseStream, cancellationToken)
+					.ConfigureAwait(false) as TResponse;
+
+			// TODO: Handle empty data in a nicer way as throwing exceptions has a cost we'd like to avoid!
+			// ie. check content-length (add to ApiCallDetails)?
+			try
+			{
+				if (requiresErrorDeserialization && TryGetError(details, requestData, responseStream, out var error) && error.HasError())
 				{
-					return default;
+					var response = new TResponse();
+					SetErrorOnResponse(response, error);
+					return response;
 				}
+
+				return mimeType == null || !mimeType.StartsWith(requestData.Accept, StringComparison.Ordinal)
+					? default
+					: await serializer
+						.DeserializeAsync<TResponse>(responseStream, cancellationToken)
+						.ConfigureAwait(false);
+			}
+			catch (JsonException ex) when (ex.Message.Contains("The input does not contain any JSON tokens"))
+			{
+				return default;
 			}
 		}
+	}
 
-		
-		private static bool SetSpecialTypes<TResponse>(string mimeType, byte[] bytes,
-			IMemoryStreamFactory memoryStreamFactory, out TResponse cs)
-			where TResponse : class, ITransportResponse, new()
+	
+	private static bool SetSpecialTypes<TResponse>(string mimeType, byte[] bytes,
+		MemoryStreamFactory memoryStreamFactory, out TResponse cs)
+		where TResponse : TransportResponse, new()
+	{
+		cs = null;
+		var responseType = typeof(TResponse);
+		if (!SpecialTypes.Contains(responseType)) return false;
+
+		if (responseType == typeof(StringResponse))
+			cs = new StringResponse(bytes.Utf8String()) as TResponse;
+		else if (responseType == typeof(BytesResponse))
+			cs = new BytesResponse(bytes) as TResponse;
+		else if (responseType == typeof(VoidResponse))
+			cs = VoidResponse.Default as TResponse;
+		else if (responseType == typeof(DynamicResponse))
 		{
-			cs = null;
-			var responseType = typeof(TResponse);
-			if (!SpecialTypes.Contains(responseType)) return false;
-
-			if (responseType == typeof(StringResponse))
-				cs = new StringResponse(bytes.Utf8String()) as TResponse;
-			else if (responseType == typeof(BytesResponse))
-				cs = new BytesResponse(bytes) as TResponse;
-			else if (responseType == typeof(VoidResponse))
-				cs = VoidResponse.Default as TResponse;
-			else if (responseType == typeof(DynamicResponse))
+			//if not json store the result under "body"
+			if (mimeType == null || !mimeType.StartsWith(RequestData.MimeType))
 			{
-				//if not json store the result under "body"
-				if (mimeType == null || !mimeType.StartsWith(RequestData.MimeType))
+				var dictionary = new DynamicDictionary
 				{
-					var dictionary = new DynamicDictionary
-					{
-						["body"] = new DynamicValue(bytes.Utf8String())
-					};
-					cs = new DynamicResponse(dictionary) as TResponse;
-				}
-				else
-				{
-					using var ms = memoryStreamFactory.Create(bytes);
-					var body = LowLevelRequestResponseSerializer.Instance.Deserialize<DynamicDictionary>(ms);
-					cs = new DynamicResponse(body) as TResponse;
-				}
+					["body"] = new DynamicValue(bytes.Utf8String())
+				};
+				cs = new DynamicResponse(dictionary) as TResponse;
+			}
+			else
+			{
+				using var ms = memoryStreamFactory.Create(bytes);
+				var body = LowLevelRequestResponseSerializer.Instance.Deserialize<DynamicDictionary>(ms);
+				cs = new DynamicResponse(body) as TResponse;
 			}
-
-			return cs != null;
 		}
 
-		private static bool NeedsToEagerReadStream<TResponse>()
-			where TResponse : class, ITransportResponse, new() =>
-			typeof(TResponse) == typeof(StringResponse)
-			|| typeof(TResponse) == typeof(BytesResponse)
-			|| typeof(TResponse) == typeof(DynamicResponse);
+		return cs != null;
+	}
+
+	private static bool NeedsToEagerReadStream<TResponse>()
+		where TResponse : TransportResponse, new() =>
+		typeof(TResponse) == typeof(StringResponse)
+		|| typeof(TResponse) == typeof(BytesResponse)
+		|| typeof(TResponse) == typeof(DynamicResponse);
 
-		private static byte[] SwapStreams(ref Stream responseStream, ref MemoryStream ms)
-		{
-			var bytes = ms.ToArray();
-			responseStream.Dispose();
-			responseStream = ms;
-			responseStream.Position = 0;
-			return bytes;
-		}
+	private static byte[] SwapStreams(ref Stream responseStream, ref MemoryStream ms)
+	{
+		var bytes = ms.ToArray();
+		responseStream.Dispose();
+		responseStream = ms;
+		responseStream.Position = 0;
+		return bytes;
 	}
 }
diff --git a/src/Elastic.Transport/Components/Pipeline/IRequestPipeline.cs b/src/Elastic.Transport/Components/Pipeline/IRequestPipeline.cs
deleted file mode 100644
index ca50215..0000000
--- a/src/Elastic.Transport/Components/Pipeline/IRequestPipeline.cs
+++ /dev/null
@@ -1,100 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using Elastic.Transport.Diagnostics.Auditing;
-
-namespace Elastic.Transport
-{
-	/// <summary> Models the workflow of a request to multiple nodes</summary>
-	public interface IRequestPipeline : IDisposable // TODO - Should we move IDisposable to the implementation / Make this an abstract base type instead?
-	{
-		//TODO should not be List but requires a refactor
-		/// <summary>
-		/// An audit trail that can be used for logging and debugging purposes. Giving insights into how
-		/// the request made its way through the workflow
-		/// </summary>
-		List<Audit> AuditTrail { get; }
-
-		/// <summary>
-		/// Should the workflow attempt the initial sniff as requested by
-		/// <see cref="ITransportConfiguration.SniffsOnStartup" />
-		/// </summary>
-		bool FirstPoolUsageNeedsSniffing { get; }
-
-//TODO xmldocs
-#pragma warning disable 1591
-		bool IsTakingTooLong { get; }
-
-		int MaxRetries { get; }
-
-		int Retried { get; }
-
-		bool SniffsOnConnectionFailure { get; }
-
-		bool SniffsOnStaleCluster { get; }
-
-		bool StaleClusterState { get; }
-
-		DateTime StartedOn { get; }
-
-		TResponse CallProductEndpoint<TResponse>(RequestData requestData)
-			where TResponse : class, ITransportResponse, new();
-
-		Task<TResponse> CallProductEndpointAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken)
-			where TResponse : class, ITransportResponse, new();
-
-		void MarkAlive(Node node);
-
-		void MarkDead(Node node);
-
-		/// <summary>
-		/// Attempt to get a single node when the underlying connection pool contains only one node.
-		/// <para>
-		/// This provides an optimised path for single node pools by avoiding an Enumerator on each call.
-		/// </para>
-		/// </summary>
-		/// <param name="node"></param>
-		/// <returns><c>true</c> when a single node exists which has been set on the <paramref name="node" />.</returns>
-		bool TryGetSingleNode(out Node node);
-
-		IEnumerable<Node> NextNode();
-
-		void Ping(Node node);
-
-		Task PingAsync(Node node, CancellationToken cancellationToken);
-
-		void FirstPoolUsage(SemaphoreSlim semaphore);
-
-		Task FirstPoolUsageAsync(SemaphoreSlim semaphore, CancellationToken cancellationToken);
-
-		void Sniff();
-
-		Task SniffAsync(CancellationToken cancellationToken);
-
-		void SniffOnStaleCluster();
-
-		Task SniffOnStaleClusterAsync(CancellationToken cancellationToken);
-
-		void SniffOnConnectionFailure();
-
-		Task SniffOnConnectionFailureAsync(CancellationToken cancellationToken);
-
-		void BadResponse<TResponse>(ref TResponse response, IApiCallDetails callDetails, RequestData data, TransportException exception)
-			where TResponse : class, ITransportResponse, new();
-
-		void ThrowNoNodesAttempted(RequestData requestData, List<PipelineException> seenExceptions);
-
-		void AuditCancellationRequested();
-
-		TransportException CreateClientException<TResponse>(TResponse response, IApiCallDetails callDetails, RequestData data,
-			List<PipelineException> seenExceptions
-		)
-			where TResponse : class, ITransportResponse, new();
-#pragma warning restore 1591
-	}
-}
diff --git a/src/Elastic.Transport/Components/Pipeline/PipelineException.cs b/src/Elastic.Transport/Components/Pipeline/PipelineException.cs
index 6e44554..aeeb988 100644
--- a/src/Elastic.Transport/Components/Pipeline/PipelineException.cs
+++ b/src/Elastic.Transport/Components/Pipeline/PipelineException.cs
@@ -4,63 +4,51 @@
 
 using System;
 
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// A pipeline exception is throw when ever a known failing exit point is reached in <see cref="RequestPipeline{TConfiguration}"/>
-	/// <para>See <see cref="PipelineFailure"/> for known exits points</para>
-	/// </summary>
-	public class PipelineException : Exception
-	{
-		/// <inheritdoc cref="PipelineException"/>
-		public PipelineException(PipelineFailure failure)
-			: base(GetMessage(failure)) => FailureReason = failure;
-
-		/// <inheritdoc cref="PipelineException"/>
-		public PipelineException(PipelineFailure failure, Exception innerException)
-			: base(GetMessage(failure), innerException) => FailureReason = failure;
+namespace Elastic.Transport;
 
-		/// <inheritdoc cref="PipelineFailure"/>
-		public PipelineFailure FailureReason { get; }
+/// <summary>
+/// A pipeline exception is throw when ever a known failing exit point is reached in <see cref="DefaultRequestPipeline{TConfiguration}"/>
+/// <para>See <see cref="PipelineFailure"/> for known exits points</para>
+/// </summary>
+public class PipelineException : Exception
+{
+	/// <inheritdoc cref="PipelineException"/>
+	public PipelineException(PipelineFailure failure)
+		: base(GetMessage(failure)) => FailureReason = failure;
 
-		/// <summary>
-		/// This exception is one the <see cref="ITransport{TConnectionSettings}"/> can handle
-		/// <para><see cref="PipelineFailure.BadRequest"/></para>
-		/// <para><see cref="PipelineFailure.BadResponse"/></para>
-		/// <para><see cref="PipelineFailure.PingFailure"/></para>
-		/// </summary>
-		public bool Recoverable =>
-			FailureReason == PipelineFailure.BadRequest
-			|| FailureReason == PipelineFailure.BadResponse
-			|| FailureReason == PipelineFailure.PingFailure;
+	/// <inheritdoc cref="PipelineException"/>
+	public PipelineException(PipelineFailure failure, Exception innerException)
+		: base(GetMessage(failure), innerException) => FailureReason = failure;
 
-		//TODO why do we have both Response and ApiCall?
+	/// <inheritdoc cref="PipelineFailure"/>
+	public PipelineFailure FailureReason { get; }
 
-		/// <summary> The response that triggered this exception </summary>
-		public ITransportResponse Response { get; internal set; }
+	/// <summary>
+	/// This exception is one the <see cref="HttpTransport{TConnectionSettings}"/> can handle
+	/// <para><see cref="PipelineFailure.BadRequest"/></para>
+	/// <para><see cref="PipelineFailure.BadResponse"/></para>
+	/// <para><see cref="PipelineFailure.PingFailure"/></para>
+	/// </summary>
+	public bool Recoverable =>
+		FailureReason == PipelineFailure.BadRequest
+		|| FailureReason == PipelineFailure.BadResponse
+		|| FailureReason == PipelineFailure.PingFailure;
 
-		/// <summary> The response that triggered this exception </summary>
-		public IApiCallDetails ApiCall { get; internal set; }
+	/// <summary> The response that triggered this exception </summary>
+	public TransportResponse Response { get; internal set; }
 
-		private static string GetMessage(PipelineFailure failure)
+	private static string GetMessage(PipelineFailure failure) =>
+		failure switch
 		{
-			switch (failure)
-			{
-				case PipelineFailure.BadRequest: return "An error occurred trying to write the request data to the specified node.";
-				case PipelineFailure.BadResponse: return "An error occurred trying to read the response from the specified node.";
-				case PipelineFailure.BadAuthentication:
-					return "Could not authenticate with the specified node. Try verifying your credentials or check your Shield configuration.";
-				case PipelineFailure.PingFailure: return "Failed to ping the specified node.";
-				case PipelineFailure.SniffFailure: return "Failed sniffing cluster state.";
-				case PipelineFailure.CouldNotStartSniffOnStartup: return "Failed sniffing cluster state upon client startup.";
-				case PipelineFailure.MaxTimeoutReached: return "Maximum timeout was reached.";
-				case PipelineFailure.MaxRetriesReached: return "The call was retried the configured maximum amount of times";
-				case PipelineFailure.NoNodesAttempted:
-					return "No nodes were attempted, this can happen when a node predicate does not match any nodes";
-				case PipelineFailure.Unexpected:
-				default:
-					return "An unexpected error occurred. Try checking the original exception for more information.";
-			}
-		}
-	}
+			PipelineFailure.BadRequest => "An error occurred trying to write the request data to the specified node.",
+			PipelineFailure.BadResponse => "An error occurred trying to read the response from the specified node.",
+			PipelineFailure.BadAuthentication => "Could not authenticate with the specified node. Try verifying your credentials or check your Shield configuration.",
+			PipelineFailure.PingFailure => "Failed to ping the specified node.",
+			PipelineFailure.SniffFailure => "Failed sniffing cluster state.",
+			PipelineFailure.CouldNotStartSniffOnStartup => "Failed sniffing cluster state upon client startup.",
+			PipelineFailure.MaxTimeoutReached => "Maximum timeout was reached.",
+			PipelineFailure.MaxRetriesReached => "The call was retried the configured maximum amount of times",
+			PipelineFailure.NoNodesAttempted => "No nodes were attempted, this can happen when a node predicate does not match any nodes",
+			_ => "An unexpected error occurred. Try checking the original exception for more information.",
+		};
 }
diff --git a/src/Elastic.Transport/Components/Pipeline/PipelineFailure.cs b/src/Elastic.Transport/Components/Pipeline/PipelineFailure.cs
index 317e473..be86684 100644
--- a/src/Elastic.Transport/Components/Pipeline/PipelineFailure.cs
+++ b/src/Elastic.Transport/Components/Pipeline/PipelineFailure.cs
@@ -4,56 +4,55 @@
 
 using Elastic.Transport.Products;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A failure in <see cref="DefaultRequestPipeline{TConfiguration}"/>'s workflow that caused it to end prematurely.
+/// </summary>
+public enum PipelineFailure
 {
 	/// <summary>
-	/// A failure in <see cref="RequestPipeline{TConfiguration}"/>'s workflow that caused it to end prematurely.
+	/// The provided credentials were insufficient.
+	/// <para>If this is thrown during an initial sniff or ping it short circuits and returns immediately</para>
+	/// </summary>
+	BadAuthentication,
+
+	/// <summary>
+	/// A bad response as determined by <see cref="ProductRegistration.HttpStatusCodeClassifier"/>
+	/// </summary>
+	BadResponse,
+
+	/// <summary> A ping request was unsuccessful</summary>
+	PingFailure,
+	/// <summary> A sniff request was unsuccessful</summary>
+	SniffFailure,
+
+	/// <summary>
+	/// See <see cref="ITransportConfiguration.SniffsOnStartup"/> was requested but the first API call failed to sniff
+	/// </summary>
+	CouldNotStartSniffOnStartup,
+
+	/// <summary>
+	/// The overall timeout specified by <see cref="ITransportConfiguration.MaxRetryTimeout"/> was reached
+	/// </summary>
+	MaxTimeoutReached,
+
+	/// <summary>
+	/// The overall max retries as specified by <see cref="ITransportConfiguration.MaxRetries"/> was reached
+	/// </summary>
+	MaxRetriesReached,
+
+	/// <summary>
+	/// An exception occurred during <see cref="DefaultRequestPipeline{TConfiguration}"/> that could not be handled
+	/// </summary>
+	Unexpected,
+
+	/// <summary> An exception happened while sending the request and a response was never fetched </summary>
+	BadRequest,
+
+	/// <summary>
+	/// Rare but if <see cref="ITransportConfiguration.NodePredicate"/> is too stringent it could mean no
+	/// nodes were considered for the API call
 	/// </summary>
-	public enum PipelineFailure
-	{
-		/// <summary>
-		/// The provided credentials were insufficient.
-		/// <para>If this is thrown during an initial sniff or ping it short circuits and returns immediately</para>
-		/// </summary>
-		BadAuthentication,
-
-		/// <summary>
-		/// A bad response as determined by <see cref="IProductRegistration.HttpStatusCodeClassifier"/>
-		/// </summary>
-		BadResponse,
-
-		/// <summary> A ping request was unsuccessful</summary>
-		PingFailure,
-		/// <summary> A sniff request was unsuccessful</summary>
-		SniffFailure,
-
-		/// <summary>
-		/// See <see cref="ITransportConfiguration.SniffsOnStartup"/> was requested but the first API call failed to sniff
-		/// </summary>
-		CouldNotStartSniffOnStartup,
-
-		/// <summary>
-		/// The overall timeout specified by <see cref="ITransportConfiguration.MaxRetryTimeout"/> was reached
-		/// </summary>
-		MaxTimeoutReached,
-
-		/// <summary>
-		/// The overall max retries as specified by <see cref="ITransportConfiguration.MaxRetries"/> was reached
-		/// </summary>
-		MaxRetriesReached,
-
-		/// <summary>
-		/// An exception occurred during <see cref="RequestPipeline{TConfiguration}"/> that could not be handled
-		/// </summary>
-		Unexpected,
-
-		/// <summary> An exception happened while sending the request and a response was never fetched </summary>
-		BadRequest,
-
-		/// <summary>
-		/// Rare but if <see cref="ITransportConfiguration.NodePredicate"/> is too stringent it could mean no
-		/// nodes were considered for the API call
-		/// </summary>
-		NoNodesAttempted
-	}
+	NoNodesAttempted
 }
diff --git a/src/Elastic.Transport/Components/Pipeline/RequestData.cs b/src/Elastic.Transport/Components/Pipeline/RequestData.cs
index 8b31a07..9d02054 100644
--- a/src/Elastic.Transport/Components/Pipeline/RequestData.cs
+++ b/src/Elastic.Transport/Components/Pipeline/RequestData.cs
@@ -5,226 +5,224 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
-using System.Security;
 using System.Security.Cryptography.X509Certificates;
 using Elastic.Transport.Diagnostics.Auditing;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Where and how <see cref="TransportClient.Request{TResponse}" /> should connect to.
+/// <para>
+/// Represents the cumulative configuration from <see cref="ITransportConfiguration" />
+/// and <see cref="IRequestConfiguration" />.
+/// </para>
+/// </summary>
+public sealed class RequestData
 {
-	/// <summary>
-	/// Where and how <see cref="ITransportClient.Request{TResponse}" /> should connect to.
-	/// <para>
-	/// Represents the cumulative configuration from <see cref="ITransportConfiguration" />
-	/// and <see cref="IRequestConfiguration" />.
-	/// </para>
-	/// </summary>
-	public sealed class RequestData
-	{
 //TODO add xmldocs and clean up this class
 #pragma warning disable 1591
-		public const string MimeType = "application/json";
-		public const string MimeTypeTextPlain = "text/plain";
-		public const string OpaqueIdHeader = "X-Opaque-Id";
-		public const string RunAsSecurityHeader = "es-security-runas-user";
-
-		private Uri _requestUri;
-		private Node _node;
-
-		public RequestData(
-			HttpMethod method, string path,
-			PostData data,
-			ITransportConfiguration global,
-			IRequestParameters local,
-			IMemoryStreamFactory memoryStreamFactory
-		)
-			: this(method, data, global, local?.RequestConfiguration, memoryStreamFactory)
+	public const string MimeType = "application/json";
+	public const string MimeTypeTextPlain = "text/plain";
+	public const string OpaqueIdHeader = "X-Opaque-Id";
+	public const string RunAsSecurityHeader = "es-security-runas-user";
+
+	private Uri _requestUri;
+	private Node _node;
+
+	public RequestData(
+		HttpMethod method, string path,
+		PostData data,
+		ITransportConfiguration global,
+		RequestParameters local,
+		MemoryStreamFactory memoryStreamFactory
+	)
+		: this(method, data, global, local?.RequestConfiguration, memoryStreamFactory)
+	{
+		_path = path;
+		CustomResponseBuilder = local?.CustomResponseBuilder;
+		PathAndQuery = CreatePathWithQueryStrings(path, ConnectionSettings, local);
+	}
+
+	private RequestData(HttpMethod method,
+		PostData data,
+		ITransportConfiguration global,
+		IRequestConfiguration local,
+		MemoryStreamFactory memoryStreamFactory
+	)
+	{
+		ConnectionSettings = global;
+		MemoryStreamFactory = memoryStreamFactory;
+		Method = method;
+		PostData = data;
+
+		if (data != null)
+			data.DisableDirectStreaming = local?.DisableDirectStreaming ?? global.DisableDirectStreaming;
+
+		Pipelined = local?.EnableHttpPipelining ?? global.HttpPipeliningEnabled;
+		HttpCompression = global.EnableHttpCompression;
+		RequestMimeType = local?.ContentType ?? MimeType;
+		Accept = local?.Accept ?? MimeType;
+
+		if (global.Headers != null)
+			Headers = new NameValueCollection(global.Headers);
+
+		if (local?.Headers != null)
+		{
+			Headers ??= new NameValueCollection();
+			foreach (var key in local.Headers.AllKeys)
+				Headers[key] = local.Headers[key];
+		}
+
+		if (!string.IsNullOrEmpty(local?.OpaqueId))
 		{
-			_path = path;
-			CustomResponseBuilder = local?.CustomResponseBuilder;
-			PathAndQuery = CreatePathWithQueryStrings(path, ConnectionSettings, local);
+			Headers ??= new NameValueCollection();
+			Headers.Add(OpaqueIdHeader, local.OpaqueId);
 		}
 
-		private RequestData(HttpMethod method,
-			PostData data,
-			ITransportConfiguration global,
-			IRequestConfiguration local,
-			IMemoryStreamFactory memoryStreamFactory
-		)
+		RunAs = local?.RunAs;
+		SkipDeserializationForStatusCodes = global.SkipDeserializationForStatusCodes;
+		ThrowExceptions = local?.ThrowExceptions ?? global.ThrowExceptions;
+
+		RequestTimeout = local?.RequestTimeout ?? global.RequestTimeout;
+		PingTimeout =
+			local?.PingTimeout
+			?? global.PingTimeout
+			?? (global.NodePool.UsingSsl ? TransportConfiguration.DefaultPingTimeoutOnSsl : TransportConfiguration.DefaultPingTimeout);
+
+		KeepAliveInterval = (int)(global.KeepAliveInterval?.TotalMilliseconds ?? 2000);
+		KeepAliveTime = (int)(global.KeepAliveTime?.TotalMilliseconds ?? 2000);
+		DnsRefreshTimeout = global.DnsRefreshTimeout;
+
+		MetaHeaderProvider = global.MetaHeaderProvider;
+		RequestMetaData = local?.RequestMetaData?.Items ?? EmptyReadOnly<string, string>.Dictionary;
+
+		ProxyAddress = global.ProxyAddress;
+		ProxyUsername = global.ProxyUsername;
+		ProxyPassword = global.ProxyPassword;
+		DisableAutomaticProxyDetection = global.DisableAutomaticProxyDetection;
+		AuthenticationHeader = local?.AuthenticationHeader ?? global.Authentication;
+		AllowedStatusCodes = local?.AllowedStatusCodes ?? EmptyReadOnly<int>.Collection;
+		ClientCertificates = local?.ClientCertificates ?? global.ClientCertificates;
+		UserAgent = global.UserAgent;
+		TransferEncodingChunked = local?.TransferEncodingChunked ?? global.TransferEncodingChunked;
+		TcpStats = local?.EnableTcpStats ?? global.EnableTcpStats;
+		ThreadPoolStats = local?.EnableThreadPoolStats ?? global.EnableThreadPoolStats;
+		ParseAllHeaders = local?.ParseAllHeaders ?? global.ParseAllHeaders ?? false;
+
+		if (local is not null)
 		{
-			ConnectionSettings = global;
-			MemoryStreamFactory = memoryStreamFactory;
-			Method = method;
-			PostData = data;
-
-			if (data != null)
-				data.DisableDirectStreaming = local?.DisableDirectStreaming ?? global.DisableDirectStreaming;
-
-			Pipelined = local?.EnableHttpPipelining ?? global.HttpPipeliningEnabled;
-			HttpCompression = global.EnableHttpCompression;
-			RequestMimeType = local?.ContentType ?? MimeType;
-			Accept = local?.Accept ?? MimeType;
-
-			if (global.Headers != null)
-				Headers = new NameValueCollection(global.Headers);
-
-			if (local?.Headers != null)
-			{
-				Headers ??= new NameValueCollection();
-				foreach (var key in local.Headers.AllKeys)
-					Headers[key] = local.Headers[key];
-			}
-
-			if (!string.IsNullOrEmpty(local?.OpaqueId))
-			{
-				Headers ??= new NameValueCollection();
-				Headers.Add(OpaqueIdHeader, local.OpaqueId);
-			}
-
-			RunAs = local?.RunAs;
-			SkipDeserializationForStatusCodes = global.SkipDeserializationForStatusCodes;
-			ThrowExceptions = local?.ThrowExceptions ?? global.ThrowExceptions;
-
-			RequestTimeout = local?.RequestTimeout ?? global.RequestTimeout;
-			PingTimeout =
-				local?.PingTimeout
-				?? global.PingTimeout
-				?? (global.NodePool.UsingSsl ? TransportConfiguration.DefaultPingTimeoutOnSsl : TransportConfiguration.DefaultPingTimeout);
-
-			KeepAliveInterval = (int)(global.KeepAliveInterval?.TotalMilliseconds ?? 2000);
-			KeepAliveTime = (int)(global.KeepAliveTime?.TotalMilliseconds ?? 2000);
-			DnsRefreshTimeout = global.DnsRefreshTimeout;
-
-			MetaHeaderProvider = global.MetaHeaderProvider;
-			RequestMetaData = local?.RequestMetaData?.Items ?? EmptyReadOnly<string, string>.Dictionary;
-
-			ProxyAddress = global.ProxyAddress;
-			ProxyUsername = global.ProxyUsername;
-			ProxyPassword = global.ProxyPassword;
-			DisableAutomaticProxyDetection = global.DisableAutomaticProxyDetection;
-			AuthenticationHeader = local?.AuthenticationHeader ?? global.Authentication;
-			AllowedStatusCodes = local?.AllowedStatusCodes ?? EmptyReadOnly<int>.Collection;
-			ClientCertificates = local?.ClientCertificates ?? global.ClientCertificates;
-			UserAgent = global.UserAgent;
-			TransferEncodingChunked = local?.TransferEncodingChunked ?? global.TransferEncodingChunked;
-			TcpStats = local?.EnableTcpStats ?? global.EnableTcpStats;
-			ThreadPoolStats = local?.EnableThreadPoolStats ?? global.EnableThreadPoolStats;
-			ParseAllHeaders = local?.ParseAllHeaders ?? global.ParseAllHeaders ?? false;
-
-			if (local is not null)
-			{
-				ResponseHeadersToParse = local.ResponseHeadersToParse;
-				ResponseHeadersToParse = new HeadersList(local.ResponseHeadersToParse, global.ResponseHeadersToParse);
-			}
-			else
-			{
-				ResponseHeadersToParse = global.ResponseHeadersToParse;
-			}
+			ResponseHeadersToParse = local.ResponseHeadersToParse;
+			ResponseHeadersToParse = new HeadersList(local.ResponseHeadersToParse, global.ResponseHeadersToParse);
 		}
+		else
+		{
+			ResponseHeadersToParse = global.ResponseHeadersToParse;
+		}
+	}
 
-		private readonly string _path;
-
-		public string Accept { get; }
-		public IReadOnlyCollection<int> AllowedStatusCodes { get; }
-		public AuthorizationHeader AuthenticationHeader { get; }
-		public X509CertificateCollection ClientCertificates { get; }
-		public ITransportConfiguration ConnectionSettings { get; }
-		public CustomResponseBuilder CustomResponseBuilder { get; }
-		public bool DisableAutomaticProxyDetection { get; }
-		public HeadersList ResponseHeadersToParse { get; }
-		public bool ParseAllHeaders { get; }
-		public NameValueCollection Headers { get; }
-		public bool HttpCompression { get; }
-		public int KeepAliveInterval { get; }
-		public int KeepAliveTime { get; }
-		public bool MadeItToResponse { get; set; }
-		public IMemoryStreamFactory MemoryStreamFactory { get; }
-		public HttpMethod Method { get; }
-
-		public Node Node
+	private readonly string _path;
+
+	public string Accept { get; }
+	public IReadOnlyCollection<int> AllowedStatusCodes { get; }
+	public AuthorizationHeader AuthenticationHeader { get; }
+	public X509CertificateCollection ClientCertificates { get; }
+	public ITransportConfiguration ConnectionSettings { get; }
+	public CustomResponseBuilder CustomResponseBuilder { get; }
+	public bool DisableAutomaticProxyDetection { get; }
+	public HeadersList ResponseHeadersToParse { get; }
+	public bool ParseAllHeaders { get; }
+	public NameValueCollection Headers { get; }
+	public bool HttpCompression { get; }
+	public int KeepAliveInterval { get; }
+	public int KeepAliveTime { get; }
+	public bool MadeItToResponse { get; set; }
+	public MemoryStreamFactory MemoryStreamFactory { get; }
+	public HttpMethod Method { get; }
+
+	public Node Node
+	{
+		get => _node;
+		set
 		{
-			get => _node;
-			set
-			{
-				// We want the Uri to regenerate when the node changes
-				_requestUri = null;
-				_node = value;
-			}
+			// We want the Uri to regenerate when the node changes
+			_requestUri = null;
+			_node = value;
 		}
+	}
+
+	public AuditEvent OnFailureAuditEvent => MadeItToResponse ? AuditEvent.BadResponse : AuditEvent.BadRequest;
+	public PipelineFailure OnFailurePipelineFailure => MadeItToResponse ? PipelineFailure.BadResponse : PipelineFailure.BadRequest;
+	public string PathAndQuery { get; }
+	public TimeSpan PingTimeout { get; }
+	public bool Pipelined { get; }
+	public PostData PostData { get; }
+	public string ProxyAddress { get; }
+	public string ProxyPassword { get; }
+	public string ProxyUsername { get; }
+	// TODO: rename to ContentType in 8.0.0
+	public string RequestMimeType { get; }
+	public TimeSpan RequestTimeout { get; }
+	public string RunAs { get; }
+	public IReadOnlyCollection<int> SkipDeserializationForStatusCodes { get; }
+	public bool ThrowExceptions { get; }
+	public UserAgent UserAgent { get; }
+	public bool TransferEncodingChunked { get; }
+	public bool TcpStats { get; }
+	public bool ThreadPoolStats { get; }
 
-		public AuditEvent OnFailureAuditEvent => MadeItToResponse ? AuditEvent.BadResponse : AuditEvent.BadRequest;
-		public PipelineFailure OnFailurePipelineFailure => MadeItToResponse ? PipelineFailure.BadResponse : PipelineFailure.BadRequest;
-		public string PathAndQuery { get; }
-		public TimeSpan PingTimeout { get; }
-		public bool Pipelined { get; }
-		public PostData PostData { get; }
-		public string ProxyAddress { get; }
-		public string ProxyPassword { get; }
-		public string ProxyUsername { get; }
-		// TODO: rename to ContentType in 8.0.0
-		public string RequestMimeType { get; }
-		public TimeSpan RequestTimeout { get; }
-		public string RunAs { get; }
-		public IReadOnlyCollection<int> SkipDeserializationForStatusCodes { get; }
-		public bool ThrowExceptions { get; }
-		public UserAgent UserAgent { get; }
-		public bool TransferEncodingChunked { get; }
-		public bool TcpStats { get; }
-		public bool ThreadPoolStats { get; }
-
-		/// <summary>
-		/// The <see cref="Uri" /> for the request.
-		/// </summary>
-		public Uri Uri
+	/// <summary>
+	/// The <see cref="Uri" /> for the request.
+	/// </summary>
+	public Uri Uri
+	{
+		get
 		{
-			get
-			{
-				if (_requestUri is not null) return _requestUri;
+			if (_requestUri is not null) return _requestUri;
 
-				_requestUri = Node is not null ? new Uri(Node.Uri, PathAndQuery) : null;
-				return _requestUri;
-			}
+			_requestUri = Node is not null ? new Uri(Node.Uri, PathAndQuery) : null;
+			return _requestUri;
 		}
+	}
 
-		public TimeSpan DnsRefreshTimeout { get; }
+	public TimeSpan DnsRefreshTimeout { get; }
 
-		public MetaHeaderProvider MetaHeaderProvider { get; }
+	public MetaHeaderProvider MetaHeaderProvider { get; }
 
-		public IReadOnlyDictionary<string, string> RequestMetaData { get; }
+	public IReadOnlyDictionary<string, string> RequestMetaData { get; }
 
-		public bool IsAsync { get; internal set; }
+	public bool IsAsync { get; internal set; }
 
-		public override string ToString() => $"{Method.GetStringValue()} {_path}";
+	public override string ToString() => $"{Method.GetStringValue()} {_path}";
 
-		// TODO This feels like its in the wrong place
-		private string CreatePathWithQueryStrings(string path, ITransportConfiguration global, IRequestParameters request)
-		{
-			path ??= string.Empty;
-			if (path.Contains("?"))
-				throw new ArgumentException($"{nameof(path)} can not contain querystring parameters and needs to be already escaped");
+	// TODO This feels like its in the wrong place
+	private string CreatePathWithQueryStrings(string path, ITransportConfiguration global, RequestParameters request)
+	{
+		path ??= string.Empty;
+		if (path.Contains("?"))
+			throw new ArgumentException($"{nameof(path)} can not contain querystring parameters and needs to be already escaped");
 
-			var g = global.QueryStringParameters;
-			var l = request?.QueryString;
+		var g = global.QueryStringParameters;
+		var l = request?.QueryString;
 
-			if ((g == null || g.Count == 0) && (l == null || l.Count == 0)) return path;
+		if ((g == null || g.Count == 0) && (l == null || l.Count == 0)) return path;
 
-			//create a copy of the global query string collection if needed.
-			var nv = g == null ? new NameValueCollection() : new NameValueCollection(g);
+		//create a copy of the global query string collection if needed.
+		var nv = g == null ? new NameValueCollection() : new NameValueCollection(g);
 
-			//set all querystring pairs from local `l` on the querystring collection
-			var formatter = ConnectionSettings.UrlFormatter;
-			nv.UpdateFromDictionary(l, formatter);
+		//set all querystring pairs from local `l` on the querystring collection
+		var formatter = ConnectionSettings.UrlFormatter;
+		nv.UpdateFromDictionary(l, formatter);
 
-			//if nv has no keys simply return path as provided
-			if (!nv.HasKeys()) return path;
+		//if nv has no keys simply return path as provided
+		if (!nv.HasKeys()) return path;
 
-			//create string for query string collection where key and value are escaped properly.
-			var queryString = ToQueryString(nv);
-			path += queryString;
-			return path;
-		}
+		//create string for query string collection where key and value are escaped properly.
+		var queryString = ToQueryString(nv);
+		path += queryString;
+		return path;
+	}
 
-		public static string ToQueryString(NameValueCollection collection) => collection.ToQueryString();
+	public static string ToQueryString(NameValueCollection collection) => collection.ToQueryString();
 #pragma warning restore 1591
-	}
 }
diff --git a/src/Elastic.Transport/Components/Pipeline/RequestPipeline.cs b/src/Elastic.Transport/Components/Pipeline/RequestPipeline.cs
index 2296e9e..8bdeef6 100644
--- a/src/Elastic.Transport/Components/Pipeline/RequestPipeline.cs
+++ b/src/Elastic.Transport/Components/Pipeline/RequestPipeline.cs
@@ -4,630 +4,130 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Elastic.Transport.Diagnostics;
 using Elastic.Transport.Diagnostics.Auditing;
-using Elastic.Transport.Extensions;
-using Elastic.Transport.Products;
-using static Elastic.Transport.Diagnostics.Auditing.AuditEvent;
 
-//#if NETSTANDARD2_0 || NETSTANDARD2_1
-//using System.Threading.Tasks.Extensions;
-//#endif
+namespace Elastic.Transport;
 
-namespace Elastic.Transport
+/// <summary>
+/// Models the workflow of a request to multiple nodes
+/// </summary>
+public abstract class RequestPipeline : IDisposable
 {
-	internal static class RequestPipelineStatics
-	{
-		public static readonly string NoNodesAttemptedMessage =
-			"No nodes were attempted, this can happen when a node predicate does not match any nodes";
-
-		public static DiagnosticSource DiagnosticSource { get; } = new DiagnosticListener(DiagnosticSources.RequestPipeline.SourceName);
-	}
+	private bool _disposed = false;
 
-	/// <inheritdoc cref="IRequestPipeline" />
-	public class RequestPipeline<TConfiguration> : IRequestPipeline
-		where TConfiguration : class, ITransportConfiguration
-	{
-		private readonly ITransportClient _transportClient;
-		private readonly NodePool _nodePool;
-		private readonly IDateTimeProvider _dateTimeProvider;
-		private readonly IMemoryStreamFactory _memoryStreamFactory;
-		private readonly Func<Node, bool> _nodePredicate;
-		private readonly IProductRegistration _productRegistration;
-		private readonly TConfiguration _settings;
-		private readonly ResponseBuilder _responseBuilder;
-
-		private RequestConfiguration _pingAndSniffRequestConfiguration;
-
-		/// <inheritdoc cref="IRequestPipeline" />
-		public RequestPipeline(
-			TConfiguration configurationValues,
-			IDateTimeProvider dateTimeProvider,
-			IMemoryStreamFactory memoryStreamFactory,
-			IRequestParameters requestParameters
-		)
-		{
-			_settings = configurationValues;
-			_nodePool = _settings.NodePool;
-			_transportClient = _settings.Connection;
-			_dateTimeProvider = dateTimeProvider;
-			_memoryStreamFactory = memoryStreamFactory;
-			_productRegistration = configurationValues.ProductRegistration;
-			_responseBuilder = _productRegistration.ResponseBuilder;
-			_nodePredicate = _settings.NodePredicate ?? _productRegistration.NodePredicate;
-
-			RequestConfiguration = requestParameters?.RequestConfiguration;
-			StartedOn = dateTimeProvider.Now();
-		}
+	internal RequestPipeline() { }
 
-		/// <inheritdoc cref="IRequestPipeline.AuditTrail" />
-		public List<Audit> AuditTrail { get; } = new();
+	//TODO should not be List but requires a refactor
+	/// <summary>
+	/// An audit trail that can be used for logging and debugging purposes. Giving insights into how
+	/// the request made its way through the workflow
+	/// </summary>
+	public abstract List<Audit> AuditTrail { get; }
 
-		private RequestConfiguration PingAndSniffRequestConfiguration
-		{
-			// Lazily loaded when first required, since not all node pools and configurations support pinging and sniffing.
-			// This avoids allocating 192B per request for those which do not need to ping or sniff.
-			get
-			{
-				if (_pingAndSniffRequestConfiguration is not null) return _pingAndSniffRequestConfiguration;
-
-				_pingAndSniffRequestConfiguration = new RequestConfiguration
-				{
-					PingTimeout = PingTimeout,
-					RequestTimeout = PingTimeout,
-					AuthenticationHeader = _settings.Authentication,
-					EnableHttpPipelining = RequestConfiguration?.EnableHttpPipelining ?? _settings.HttpPipeliningEnabled,
-					ForceNode = RequestConfiguration?.ForceNode
-				};
-
-				return _pingAndSniffRequestConfiguration;
-			}
-		}
+	/// <summary>
+	/// Should the workflow attempt the initial sniff as requested by
+	/// <see cref="ITransportConfiguration.SniffsOnStartup" />
+	/// </summary>
+	public abstract bool FirstPoolUsageNeedsSniffing { get; }
 
-		//TODO xmldocs
+	//TODO xmldocs
 #pragma warning disable 1591
-		public bool DepletedRetries => Retried >= MaxRetries + 1 || IsTakingTooLong;
+	public abstract bool IsTakingTooLong { get; }
 
-		public bool FirstPoolUsageNeedsSniffing =>
-			!RequestDisabledSniff
-			&& _nodePool.SupportsReseeding && _settings.SniffsOnStartup && !_nodePool.SniffedOnStartup;
+	public abstract int MaxRetries { get; }
 
-		public bool IsTakingTooLong
-		{
-			get
-			{
-				var timeout = _settings.MaxRetryTimeout.GetValueOrDefault(RequestTimeout);
-				var now = _dateTimeProvider.Now();
-
-				//we apply a soft margin so that if a request timesout at 59 seconds when the maximum is 60 we also abort.
-				var margin = timeout.TotalMilliseconds / 100.0 * 98;
-				var marginTimeSpan = TimeSpan.FromMilliseconds(margin);
-				var timespanCall = now - StartedOn;
-				var tookToLong = timespanCall >= marginTimeSpan;
-				return tookToLong;
-			}
-		}
+	public abstract bool SniffsOnConnectionFailure { get; }
 
-		public int MaxRetries =>
-			RequestConfiguration?.ForceNode != null
-				? 0
-				: Math.Min(RequestConfiguration?.MaxRetries ?? _settings.MaxRetries.GetValueOrDefault(int.MaxValue), _nodePool.MaxRetries);
+	public abstract bool SniffsOnStaleCluster { get; }
 
-		public bool Refresh { get; private set; }
-		public int Retried { get; private set; }
+	public abstract bool StaleClusterState { get; }
 
-		public IEnumerable<Node> SniffNodes => _nodePool
-			.CreateView(LazyAuditable)
-			.ToList()
-			.OrderBy(n => _productRegistration.SniffOrder(n));
+	public abstract DateTime StartedOn { get; }
 
-		public bool SniffsOnConnectionFailure =>
-			!RequestDisabledSniff
-			&& _nodePool.SupportsReseeding && _settings.SniffsOnConnectionFault;
+	public abstract TResponse CallProductEndpoint<TResponse>(RequestData requestData)
+		where TResponse : TransportResponse, new();
 
-		public bool SniffsOnStaleCluster =>
-			!RequestDisabledSniff
-			&& _nodePool.SupportsReseeding && _settings.SniffInformationLifeSpan.HasValue;
+	public abstract Task<TResponse> CallProductEndpointAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken)
+		where TResponse : TransportResponse, new();
 
-		public bool StaleClusterState
-		{
-			get
-			{
-				if (!SniffsOnStaleCluster) return false;
-
-				// ReSharper disable once PossibleInvalidOperationException
-				// already checked by SniffsOnStaleCluster
-				var sniffLifeSpan = _settings.SniffInformationLifeSpan.Value;
-
-				var now = _dateTimeProvider.Now();
-				var lastSniff = _nodePool.LastUpdate;
-
-				return sniffLifeSpan < now - lastSniff;
-			}
-		}
+	public abstract void MarkAlive(Node node);
 
-		public DateTime StartedOn { get; }
+	public abstract void MarkDead(Node node);
 
-		private TimeSpan PingTimeout =>
-			RequestConfiguration?.PingTimeout
-			?? _settings.PingTimeout
-			?? (_nodePool.UsingSsl ? TransportConfiguration.DefaultPingTimeoutOnSsl : TransportConfiguration.DefaultPingTimeout);
+	/// <summary>
+	/// Attempt to get a single node when the underlying connection pool contains only one node.
+	/// <para>
+	/// This provides an optimised path for single node pools by avoiding an Enumerator on each call.
+	/// </para>
+	/// </summary>
+	/// <param name="node"></param>
+	/// <returns><c>true</c> when a single node exists which has been set on the <paramref name="node" />.</returns>
+	public abstract bool TryGetSingleNode(out Node node);
 
-		private IRequestConfiguration RequestConfiguration { get; }
+	public abstract IEnumerable<Node> NextNode();
 
-		private bool RequestDisabledSniff => RequestConfiguration != null && (RequestConfiguration.DisableSniff ?? false);
+	public abstract void Ping(Node node);
 
-		private TimeSpan RequestTimeout => RequestConfiguration?.RequestTimeout ?? _settings.RequestTimeout;
-
-		void IDisposable.Dispose() => Dispose();
-
-		public void AuditCancellationRequested() => Audit(CancellationRequested).Dispose();
-
-		public void BadResponse<TResponse>(ref TResponse response, IApiCallDetails callDetails, RequestData data,
-			TransportException exception
-		)
-			where TResponse : class, ITransportResponse, new()
-		{
-			if (response == null)
-			{
-				//make sure we copy over the error body in case we disabled direct streaming.
-				var s = callDetails?.ResponseBodyInBytes == null ? Stream.Null : _memoryStreamFactory.Create(callDetails.ResponseBodyInBytes);
-				var m = callDetails?.ResponseMimeType ?? RequestData.MimeType;
-				response = _responseBuilder.ToResponse<TResponse>(data, exception, callDetails?.HttpStatusCode, null, s, m, callDetails?.ResponseBodyInBytes?.Length ?? -1, null, null);
-			}
-
-			if (response.ApiCall is ApiCallDetails apiCallDetails)
-				apiCallDetails.AuditTrail = AuditTrail;
-		}
+	public abstract Task PingAsync(Node node, CancellationToken cancellationToken);
 
-		public TResponse CallProductEndpoint<TResponse>(RequestData requestData)
-			where TResponse : class, ITransportResponse, new()
-		{
-			using (var audit = Audit(HealthyResponse, requestData.Node))
-			using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, IApiCallDetails>(
-				DiagnosticSources.RequestPipeline.CallProductEndpoint, requestData))
-			{
-				audit.Path = requestData.PathAndQuery;
-				try
-				{
-					var response = _transportClient.Request<TResponse>(requestData);
-					d.EndState = response.ApiCall;
-
-					if (response.ApiCall is ApiCallDetails apiCallDetails)
-						apiCallDetails.AuditTrail = AuditTrail;
-
-					ThrowBadAuthPipelineExceptionWhenNeeded(response.ApiCall, response);
-					if (!response.ApiCall.Success) audit.Event = requestData.OnFailureAuditEvent;
-					return response;
-				}
-				catch (Exception e)
-				{
-					audit.Event = requestData.OnFailureAuditEvent;
-					audit.Exception = e;
-					throw;
-				}
-			}
-		}
+	public abstract void FirstPoolUsage(SemaphoreSlim semaphore);
 
-		public async Task<TResponse> CallProductEndpointAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken)
-			where TResponse : class, ITransportResponse, new()
-		{
-			using (var audit = Audit(HealthyResponse, requestData.Node))
-			using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, IApiCallDetails>(
-				DiagnosticSources.RequestPipeline.CallProductEndpoint, requestData))
-			{
-				audit.Path = requestData.PathAndQuery;
-				try
-				{
-					var response = await _transportClient.RequestAsync<TResponse>(requestData, cancellationToken).ConfigureAwait(false);
-					d.EndState = response.ApiCall;
-
-					if (response.ApiCall is ApiCallDetails apiCallDetails)
-						apiCallDetails.AuditTrail = AuditTrail;
-
-					ThrowBadAuthPipelineExceptionWhenNeeded(response.ApiCall, response);
-					if (!response.ApiCall.Success) audit.Event = requestData.OnFailureAuditEvent;
-					return response;
-				}
-				catch (Exception e)
-				{
-					audit.Event = requestData.OnFailureAuditEvent;
-					audit.Exception = e;
-					throw;
-				}
-			}
-		}
+	public abstract Task FirstPoolUsageAsync(SemaphoreSlim semaphore, CancellationToken cancellationToken);
 
-		public TransportException CreateClientException<TResponse>(
-			TResponse response, IApiCallDetails callDetails, RequestData data, List<PipelineException> pipelineExceptions
-		)
-			where TResponse : class, ITransportResponse, new()
-		{
-			if (callDetails?.Success ?? false) return null;
-
-			var pipelineFailure = data.OnFailurePipelineFailure;
-			var innerException = callDetails?.OriginalException;
-			if (pipelineExceptions.HasAny(out var exs))
-			{
-				pipelineFailure = exs.Last().FailureReason;
-				innerException = exs.AsAggregateOrFirst();
-			}
-
-			var statusCode = callDetails?.HttpStatusCode != null ? callDetails.HttpStatusCode.Value.ToString() : "unknown";
-			var resource = callDetails == null
-				? "unknown resource"
-				: $"Status code {statusCode} from: {callDetails.HttpMethod} {callDetails.Uri.PathAndQuery}";
-
-			var exceptionMessage = innerException?.Message ?? "Request failed to execute";
-
-			if (IsTakingTooLong)
-			{
-				pipelineFailure = PipelineFailure.MaxTimeoutReached;
-				Audit(MaxTimeoutReached);
-				exceptionMessage = "Maximum timeout reached while retrying request";
-			}
-			else if (Retried >= MaxRetries && MaxRetries > 0)
-			{
-				pipelineFailure = PipelineFailure.MaxRetriesReached;
-				Audit(MaxRetriesReached);
-				exceptionMessage = "Maximum number of retries reached";
-
-				var now = _dateTimeProvider.Now();
-				var activeNodes = _nodePool.Nodes.Count(n => n.IsAlive || n.DeadUntil <= now);
-				if (Retried >= activeNodes)
-				{
-					Audit(FailedOverAllNodes);
-					exceptionMessage += ", failed over to all the known alive nodes before failing";
-				}
-			}
-
-			exceptionMessage += !exceptionMessage.EndsWith(".", StringComparison.Ordinal) ? $". Call: {resource}" : $" Call: {resource}";
-			if (response != null && _productRegistration.TryGetServerErrorReason(response, out var reason))
-				exceptionMessage += $". ServerError: {reason}";
-
-			var clientException = new TransportException(pipelineFailure, exceptionMessage, innerException)
-			{
-				Request = data, Response = callDetails, AuditTrail = AuditTrail
-			};
-
-			return clientException;
-		}
+	public abstract void Sniff();
 
-		public void FirstPoolUsage(SemaphoreSlim semaphore)
-		{
-			if (!FirstPoolUsageNeedsSniffing) return;
-
-			if (!semaphore.Wait(_settings.RequestTimeout))
-			{
-				if (FirstPoolUsageNeedsSniffing)
-					throw new PipelineException(PipelineFailure.CouldNotStartSniffOnStartup, null);
-
-				return;
-			}
-
-			if (!FirstPoolUsageNeedsSniffing)
-			{
-				semaphore.Release();
-				return;
-			}
-
-			try
-			{
-				using (Audit(SniffOnStartup))
-				{
-					Sniff();
-					_nodePool.MarkAsSniffed();
-				}
-			}
-			finally
-			{
-				semaphore.Release();
-			}
-		}
+	public abstract Task SniffAsync(CancellationToken cancellationToken);
 
-		public async Task FirstPoolUsageAsync(SemaphoreSlim semaphore, CancellationToken cancellationToken)
-		{
-			if (!FirstPoolUsageNeedsSniffing) return;
-
-			// TODO cancellationToken could throw here and will bubble out as OperationCancelledException
-			// everywhere else it would bubble out wrapped in a `UnexpectedTransportException`
-			var success = await semaphore.WaitAsync(_settings.RequestTimeout, cancellationToken).ConfigureAwait(false);
-			if (!success)
-			{
-				if (FirstPoolUsageNeedsSniffing)
-					throw new PipelineException(PipelineFailure.CouldNotStartSniffOnStartup, null);
-
-				return;
-			}
-
-			if (!FirstPoolUsageNeedsSniffing)
-			{
-				semaphore.Release();
-				return;
-			}
-			try
-			{
-				using (Audit(SniffOnStartup))
-				{
-					await SniffAsync(cancellationToken).ConfigureAwait(false);
-					_nodePool.MarkAsSniffed();
-				}
-			}
-			finally
-			{
-				semaphore.Release();
-			}
-		}
+	public abstract void SniffOnStaleCluster();
 
-		public void MarkAlive(Node node) => node.MarkAlive();
+	public abstract Task SniffOnStaleClusterAsync(CancellationToken cancellationToken);
 
-		public void MarkDead(Node node)
-		{
-			var deadUntil = _dateTimeProvider.DeadTime(node.FailedAttempts, _settings.DeadTimeout, _settings.MaxDeadTimeout);
-			node.MarkDead(deadUntil);
-			Retried++;
-		}
+	public abstract void SniffOnConnectionFailure();
 
-		/// <inheritdoc />
-		public bool TryGetSingleNode(out Node node)
-		{
-			if (_nodePool.Nodes.Count <= 1 && _nodePool.MaxRetries <= _nodePool.Nodes.Count &&
-				!_nodePool.SupportsPinging && !_nodePool.SupportsReseeding)
-			{
-				node = _nodePool.Nodes.FirstOrDefault();
+	public abstract Task SniffOnConnectionFailureAsync(CancellationToken cancellationToken);
 
-				if (node is not null && _nodePredicate(node)) return true;
-			}
+	public abstract void BadResponse<TResponse>(ref TResponse response, ApiCallDetails callDetails, RequestData data, TransportException exception)
+		where TResponse : TransportResponse, new();
 
-			node = null;
-			return false;
-		}
+	public abstract void ThrowNoNodesAttempted(RequestData requestData, List<PipelineException> seenExceptions);
 
-		public IEnumerable<Node> NextNode()
-		{
-			if (RequestConfiguration?.ForceNode != null)
-			{
-				yield return new Node(RequestConfiguration.ForceNode);
-
-				yield break;
-			}
-
-			//This for loop allows to break out of the view state machine if we need to
-			//force a refresh (after reseeding node pool). We have a hardcoded limit of only
-			//allowing 100 of these refreshes per call
-			var refreshed = false;
-			for (var i = 0; i < 100; i++)
-			{
-				if (DepletedRetries) yield break;
-
-				foreach (var node in _nodePool.CreateView(LazyAuditable))
-				{
-					if (DepletedRetries) break;
-
-					if (!_nodePredicate(node)) continue;
-
-					yield return node;
-
-					if (!Refresh) continue;
-
-					Refresh = false;
-					refreshed = true;
-					break;
-				}
-				//unless a refresh was requested we will not iterate over more then a single view.
-				//keep in mind refreshes are also still bound to overall maxretry count/timeout.
-				if (!refreshed) break;
-			}
-		}
+	public abstract void AuditCancellationRequested();
 
-		public void Ping(Node node)
-		{
-			if (!_productRegistration.SupportsPing) return;
-			if (PingDisabled(node)) return;
-
-			var pingData = _productRegistration.CreatePingRequestData(node, PingAndSniffRequestConfiguration, _settings, _memoryStreamFactory);
-			using (var audit = Audit(PingSuccess, node))
-			using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, IApiCallDetails>(DiagnosticSources.RequestPipeline.Ping,
-				pingData))
-			{
-				audit.Path = pingData.PathAndQuery;
-				try
-				{
-					var response = _productRegistration.Ping(_transportClient, pingData);
-					d.EndState = response;
-					ThrowBadAuthPipelineExceptionWhenNeeded(response);
-					//ping should not silently accept bad but valid http responses
-					if (!response.Success)
-						throw new PipelineException(pingData.OnFailurePipelineFailure, response.OriginalException) { ApiCall = response };
-				}
-				catch (Exception e)
-				{
-					var response = (e as PipelineException)?.ApiCall;
-					audit.Event = PingFailure;
-					audit.Exception = e;
-					throw new PipelineException(PipelineFailure.PingFailure, e) { ApiCall = response };
-				}
-			}
-		}
-
-		public async Task PingAsync(Node node, CancellationToken cancellationToken)
-		{
-			if (!_productRegistration.SupportsPing) return;
-			if (PingDisabled(node)) return;
-
-			var pingData = _productRegistration.CreatePingRequestData(node, PingAndSniffRequestConfiguration, _settings, _memoryStreamFactory);
-			using (var audit = Audit(PingSuccess, node))
-			using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, IApiCallDetails>(DiagnosticSources.RequestPipeline.Ping,
-				pingData))
-			{
-				audit.Path = pingData.PathAndQuery;
-				try
-				{
-					var apiCallDetails = await _productRegistration.PingAsync(_transportClient, pingData, cancellationToken).ConfigureAwait(false);
-					d.EndState = apiCallDetails;
-					ThrowBadAuthPipelineExceptionWhenNeeded(apiCallDetails);
-					//ping should not silently accept bad but valid http responses
-					if (!apiCallDetails.Success)
-						throw new PipelineException(pingData.OnFailurePipelineFailure, apiCallDetails.OriginalException) { ApiCall = apiCallDetails };
-				}
-				catch (Exception e)
-				{
-					var response = (e as PipelineException)?.ApiCall;
-					audit.Event = PingFailure;
-					audit.Exception = e;
-					throw new PipelineException(PipelineFailure.PingFailure, e) { ApiCall = response };
-				}
-			}
-		}
-
-		public void Sniff()
-		{
-			if (!_productRegistration.SupportsSniff) return;
-
-			var exceptions = new List<Exception>();
-			foreach (var node in SniffNodes)
-			{
-				var requestData =
-					_productRegistration.CreateSniffRequestData(node, PingAndSniffRequestConfiguration, _settings, _memoryStreamFactory);
-				using (var audit = Audit(SniffSuccess, node))
-				using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, IApiCallDetails>(DiagnosticSources.RequestPipeline.Sniff,
-					requestData))
-				using (RequestPipelineStatics.DiagnosticSource.Diagnose(DiagnosticSources.RequestPipeline.Sniff, requestData))
-					try
-					{
-						audit.Path = requestData.PathAndQuery;
-						var (response, nodes) = _productRegistration.Sniff(_transportClient, _nodePool.UsingSsl, requestData);
-						d.EndState = response;
-
-						ThrowBadAuthPipelineExceptionWhenNeeded(response);
-						//sniff should not silently accept bad but valid http responses
-						if (!response.Success)
-							throw new PipelineException(requestData.OnFailurePipelineFailure, response.OriginalException) { ApiCall = response };
-
-						_nodePool.Reseed(nodes);
-						Refresh = true;
-						return;
-					}
-					catch (Exception e)
-					{
-						audit.Event = SniffFailure;
-						audit.Exception = e;
-						exceptions.Add(e);
-					}
-			}
-
-			throw new PipelineException(PipelineFailure.SniffFailure, exceptions.AsAggregateOrFirst());
-		}
-
-		public async Task SniffAsync(CancellationToken cancellationToken)
-		{
-			if (!_productRegistration.SupportsSniff) return;
-
-			var exceptions = new List<Exception>();
-			foreach (var node in SniffNodes)
-			{
-				var requestData =
-					_productRegistration.CreateSniffRequestData(node, PingAndSniffRequestConfiguration, _settings, _memoryStreamFactory);
-				using (var audit = Audit(SniffSuccess, node))
-				using (var d = RequestPipelineStatics.DiagnosticSource.Diagnose<RequestData, IApiCallDetails>(DiagnosticSources.RequestPipeline.Sniff,
-					requestData))
-					try
-					{
-						audit.Path = requestData.PathAndQuery;
-						var (response, nodes) = await _productRegistration
-							.SniffAsync(_transportClient, _nodePool.UsingSsl, requestData, cancellationToken)
-							.ConfigureAwait(false);
-						d.EndState = response;
-
-						ThrowBadAuthPipelineExceptionWhenNeeded(response);
-						//sniff should not silently accept bad but valid http responses
-						if (!response.Success)
-							throw new PipelineException(requestData.OnFailurePipelineFailure, response.OriginalException) { ApiCall = response };
-
-						_nodePool.Reseed(nodes);
-						Refresh = true;
-						return;
-					}
-					catch (Exception e)
-					{
-						audit.Event = SniffFailure;
-						audit.Exception = e;
-						exceptions.Add(e);
-					}
-			}
-
-			throw new PipelineException(PipelineFailure.SniffFailure, exceptions.AsAggregateOrFirst());
-		}
-
-		public void SniffOnConnectionFailure()
-		{
-			if (!SniffsOnConnectionFailure) return;
-
-			using (Audit(SniffOnFail))
-				Sniff();
-		}
-
-		public async Task SniffOnConnectionFailureAsync(CancellationToken cancellationToken)
-		{
-			if (!SniffsOnConnectionFailure) return;
-
-			using (Audit(SniffOnFail))
-				await SniffAsync(cancellationToken).ConfigureAwait(false);
-		}
-
-		public void SniffOnStaleCluster()
-		{
-			if (!StaleClusterState) return;
-
-			using (Audit(AuditEvent.SniffOnStaleCluster))
-			{
-				Sniff();
-				_nodePool.MarkAsSniffed();
-			}
-		}
-
-		public async Task SniffOnStaleClusterAsync(CancellationToken cancellationToken)
-		{
-			if (!StaleClusterState) return;
-
-			using (Audit(AuditEvent.SniffOnStaleCluster))
-			{
-				await SniffAsync(cancellationToken).ConfigureAwait(false);
-				_nodePool.MarkAsSniffed();
-			}
-		}
-
-		public void ThrowNoNodesAttempted(RequestData requestData, List<PipelineException> seenExceptions)
-		{
-			var clientException = new TransportException(PipelineFailure.NoNodesAttempted, RequestPipelineStatics.NoNodesAttemptedMessage,
-				(Exception)null);
-			using (Audit(NoNodesAttempted))
-				throw new UnexpectedTransportException(clientException, seenExceptions) { Request = requestData, AuditTrail = AuditTrail };
-		}
-
-		private bool PingDisabled(Node node) =>
-			(RequestConfiguration?.DisablePing).GetValueOrDefault(false)
-			|| _settings.DisablePings || !_nodePool.SupportsPinging || !node.IsResurrected;
+	public abstract TransportException CreateClientException<TResponse>(TResponse response, ApiCallDetails callDetails, RequestData data,
+		List<PipelineException> seenExceptions)
+		where TResponse : TransportResponse, new();
+#pragma warning restore 1591
 
-		private Auditable Audit(AuditEvent type, Node node = null) => new(type, AuditTrail, _dateTimeProvider, node);
+	/// <summary>
+	/// 
+	/// </summary>
+	public void Dispose()
+	{
+		Dispose(disposing: true);
+		GC.SuppressFinalize(this);
+	}
 
-		private static void ThrowBadAuthPipelineExceptionWhenNeeded(IApiCallDetails details, ITransportResponse response = null)
-		{
-			if (details?.HttpStatusCode == 401)
-				throw new PipelineException(PipelineFailure.BadAuthentication, details.OriginalException) { Response = response, ApiCall = details };
-		}
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="disposing"></param>
+	protected virtual void Dispose(bool disposing)
+	{
+		if (_disposed)
+			return;
 
-		private void LazyAuditable(AuditEvent e, Node n)
+		if (disposing)
 		{
-			using (new Auditable(e, AuditTrail, _dateTimeProvider, n)) { }
+			DisposeManagedResources();
 		}
 
-		protected virtual void Dispose() { }
+		_disposed = true;
 	}
-#pragma warning restore 1591
+
+	/// <summary>
+	/// 
+	/// </summary>
+	protected virtual void DisposeManagedResources() { }
 }
diff --git a/src/Elastic.Transport/Components/Pipeline/RequestPipelineStatics.cs b/src/Elastic.Transport/Components/Pipeline/RequestPipelineStatics.cs
new file mode 100644
index 0000000..a009e8e
--- /dev/null
+++ b/src/Elastic.Transport/Components/Pipeline/RequestPipelineStatics.cs
@@ -0,0 +1,21 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System.Diagnostics;
+using Elastic.Transport.Diagnostics;
+
+//#if NETSTANDARD2_0 || NETSTANDARD2_1
+//using System.Threading.Tasks.Extensions;
+//#endif
+
+namespace Elastic.Transport;
+
+internal static class RequestPipelineStatics
+{
+	public static readonly string NoNodesAttemptedMessage =
+		"No nodes were attempted, this can happen when a node predicate does not match any nodes";
+
+	public static DiagnosticSource DiagnosticSource { get; } = new DiagnosticListener(DiagnosticSources.RequestPipeline.SourceName);
+}
+#pragma warning restore 1591
diff --git a/src/Elastic.Transport/Components/Pipeline/ResponseBuilder.cs b/src/Elastic.Transport/Components/Pipeline/ResponseBuilder.cs
index 29b611c..132a043 100644
--- a/src/Elastic.Transport/Components/Pipeline/ResponseBuilder.cs
+++ b/src/Elastic.Transport/Components/Pipeline/ResponseBuilder.cs
@@ -10,43 +10,42 @@
 using System.Threading.Tasks;
 using Elastic.Transport.Diagnostics;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Builds a <see cref="TransportResponse"/> from the provided response data.
+/// </summary>
+public abstract class ResponseBuilder
 {
 	/// <summary>
-	/// Builds a <see cref="ITransportResponse"/> from the provided response data.
+	/// Create an instance of <typeparamref name="TResponse" /> from <paramref name="responseStream" />
 	/// </summary>
-	public abstract class ResponseBuilder
-	{
-		/// <summary>
-		/// Create an instance of <typeparamref name="TResponse" /> from <paramref name="responseStream" />
-		/// </summary>
-		public abstract TResponse ToResponse<TResponse>(
-			RequestData requestData,
-			Exception ex,
-			int? statusCode,
-			Dictionary<string, IEnumerable<string>> headers,
-			Stream responseStream,
-			string mimeType,
-			long contentLength,
-			IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
-			IReadOnlyDictionary<TcpState, int> tcpStats
+	public abstract TResponse ToResponse<TResponse>(
+		RequestData requestData,
+		Exception ex,
+		int? statusCode,
+		Dictionary<string, IEnumerable<string>> headers,
+		Stream responseStream,
+		string mimeType,
+		long contentLength,
+		IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
+		IReadOnlyDictionary<TcpState, int> tcpStats
 
-		) where TResponse : class, ITransportResponse, new();
+	) where TResponse : TransportResponse, new();
 
-		/// <summary>
-		/// Create an instance of <typeparamref name="TResponse" /> from <paramref name="responseStream" />
-		/// </summary>
-		public abstract Task<TResponse> ToResponseAsync<TResponse>(
-			RequestData requestData,
-			Exception ex,
-			int? statusCode,
-			Dictionary<string, IEnumerable<string>> headers,
-			Stream responseStream,
-			string mimeType,
-			long contentLength,
-			IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
-			IReadOnlyDictionary<TcpState, int> tcpStats,
-			CancellationToken cancellationToken = default
-		) where TResponse : class, ITransportResponse, new();
-	}
+	/// <summary>
+	/// Create an instance of <typeparamref name="TResponse" /> from <paramref name="responseStream" />
+	/// </summary>
+	public abstract Task<TResponse> ToResponseAsync<TResponse>(
+		RequestData requestData,
+		Exception ex,
+		int? statusCode,
+		Dictionary<string, IEnumerable<string>> headers,
+		Stream responseStream,
+		string mimeType,
+		long contentLength,
+		IReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats,
+		IReadOnlyDictionary<TcpState, int> tcpStats,
+		CancellationToken cancellationToken = default
+	) where TResponse : TransportResponse, new();
 }
diff --git a/src/Elastic.Transport/Components/Providers/DateTimeProvider.cs b/src/Elastic.Transport/Components/Providers/DateTimeProvider.cs
index bad05e5..283973b 100644
--- a/src/Elastic.Transport/Components/Providers/DateTimeProvider.cs
+++ b/src/Elastic.Transport/Components/Providers/DateTimeProvider.cs
@@ -4,26 +4,24 @@
 
 using System;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// An abstraction to provide access to the current <see cref="DateTime"/>. This abstraction allows time to be tested within
+/// the transport.
+/// </summary>
+public abstract class DateTimeProvider
 {
-	/// <inheritdoc cref="IDateTimeProvider"/>
-	public class DateTimeProvider : IDateTimeProvider
-	{
-		/// <summary> A static instance to reuse as <see cref="DateTimeProvider"/> is stateless </summary>
-		public static readonly DateTimeProvider Default = new();
-		private static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(60);
-		private static readonly TimeSpan MaximumTimeout = TimeSpan.FromMinutes(30);
+	internal DateTimeProvider() { }
 
-		/// <inheritdoc cref="IDateTimeProvider.DeadTime"/>
-		public virtual DateTime DeadTime(int attempts, TimeSpan? minDeadTimeout, TimeSpan? maxDeadTimeout)
-		{
-			var timeout = minDeadTimeout.GetValueOrDefault(DefaultTimeout);
-			var maxTimeout = maxDeadTimeout.GetValueOrDefault(MaximumTimeout);
-			var milliSeconds = Math.Min(timeout.TotalMilliseconds * 2 * Math.Pow(2, attempts * 0.5 - 1), maxTimeout.TotalMilliseconds);
-			return Now().AddMilliseconds(milliSeconds);
-		}
+	/// <summary> The current date time </summary>
+	public abstract DateTime Now();
 
-		/// <inheritdoc cref="IDateTimeProvider.Now"/>
-		public virtual DateTime Now() => DateTime.UtcNow;
-	}
+	/// <summary>
+	/// Calculate the dead time for a node based on the number of attempts.
+	/// </summary>
+	/// <param name="attempts">The number of attempts on the node</param>
+	/// <param name="minDeadTimeout">The initial dead time as configured by <see cref="ITransportConfiguration.DeadTimeout"/></param>
+	/// <param name="maxDeadTimeout">The configured maximum dead timeout as configured by <see cref="ITransportConfiguration.MaxDeadTimeout"/></param>
+	public abstract DateTime DeadTime(int attempts, TimeSpan? minDeadTimeout, TimeSpan? maxDeadTimeout);
 }
diff --git a/src/Elastic.Transport/Components/Providers/DefaultDateTimeProvider.cs b/src/Elastic.Transport/Components/Providers/DefaultDateTimeProvider.cs
new file mode 100644
index 0000000..fbe4c9f
--- /dev/null
+++ b/src/Elastic.Transport/Components/Providers/DefaultDateTimeProvider.cs
@@ -0,0 +1,28 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System;
+
+namespace Elastic.Transport;
+
+/// <inheritdoc cref="DateTimeProvider"/>
+public sealed class DefaultDateTimeProvider : DateTimeProvider
+{
+	/// <summary> A static instance to reuse as <see cref="DefaultDateTimeProvider"/> is stateless </summary>
+	public static readonly DefaultDateTimeProvider Default = new();
+	private static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(60);
+	private static readonly TimeSpan MaximumTimeout = TimeSpan.FromMinutes(30);
+
+	/// <inheritdoc cref="DateTimeProvider.DeadTime"/>
+	public override DateTime DeadTime(int attempts, TimeSpan? minDeadTimeout, TimeSpan? maxDeadTimeout)
+	{
+		var timeout = minDeadTimeout.GetValueOrDefault(DefaultTimeout);
+		var maxTimeout = maxDeadTimeout.GetValueOrDefault(MaximumTimeout);
+		var milliSeconds = Math.Min(timeout.TotalMilliseconds * 2 * Math.Pow(2, attempts * 0.5 - 1), maxTimeout.TotalMilliseconds);
+		return Now().AddMilliseconds(milliSeconds);
+	}
+
+	/// <inheritdoc cref="DateTimeProvider.Now"/>
+	public override DateTime Now() => DateTime.UtcNow;
+}
diff --git a/src/Elastic.Transport/Components/Providers/DefaultMemoryStreamFactory.cs b/src/Elastic.Transport/Components/Providers/DefaultMemoryStreamFactory.cs
new file mode 100644
index 0000000..be19af4
--- /dev/null
+++ b/src/Elastic.Transport/Components/Providers/DefaultMemoryStreamFactory.cs
@@ -0,0 +1,25 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System.IO;
+
+namespace Elastic.Transport;
+
+/// <summary>
+/// A factory for creating memory streams using instances of <see cref="MemoryStream" />
+/// </summary>
+public sealed class DefaultMemoryStreamFactory : MemoryStreamFactory
+{
+	/// <summary> Provide a static instance of this stateless class, so it can be reused</summary>
+	public static DefaultMemoryStreamFactory Default { get; } = new DefaultMemoryStreamFactory();
+
+	/// <inheritdoc />
+	public override MemoryStream Create() => new();
+
+	/// <inheritdoc />
+	public override MemoryStream Create(byte[] bytes) => new(bytes);
+
+	/// <inheritdoc />
+	public override MemoryStream Create(byte[] bytes, int index, int count) => new(bytes, index, count);
+}
diff --git a/src/Elastic.Transport/Components/Providers/DefaultRequestPipelineFactory.cs b/src/Elastic.Transport/Components/Providers/DefaultRequestPipelineFactory.cs
new file mode 100644
index 0000000..72df8a0
--- /dev/null
+++ b/src/Elastic.Transport/Components/Providers/DefaultRequestPipelineFactory.cs
@@ -0,0 +1,19 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+namespace Elastic.Transport;
+
+/// <summary>
+/// The default implementation for <see cref="RequestPipeline"/> that returns <see cref="DefaultRequestPipeline{TConfiguration}"/>
+/// </summary>
+internal sealed class DefaultRequestPipelineFactory<TConfiguration> : RequestPipelineFactory<TConfiguration>
+	where TConfiguration : class, ITransportConfiguration
+{
+	/// <summary>
+	/// returns instances of <see cref="DefaultRequestPipeline{TConfiguration}"/>
+	/// </summary>
+	public override RequestPipeline Create(TConfiguration configurationValues, DateTimeProvider dateTimeProvider,
+		MemoryStreamFactory memoryStreamFactory, RequestParameters requestParameters) =>
+			new DefaultRequestPipeline<TConfiguration>(configurationValues, dateTimeProvider, memoryStreamFactory, requestParameters);
+}
diff --git a/src/Elastic.Transport/Components/Providers/IDateTimeProvider.cs b/src/Elastic.Transport/Components/Providers/IDateTimeProvider.cs
deleted file mode 100644
index f1d0c62..0000000
--- a/src/Elastic.Transport/Components/Providers/IDateTimeProvider.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System;
-
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// An abstraction to provide access to the current <see cref="DateTime"/>. This abstraction allows time to be tested within
-	/// the transport.
-	/// </summary>
-	public interface IDateTimeProvider
-	{
-		/// <summary> The current date time </summary>
-		DateTime Now();
-
-		/// <summary>
-		/// Calculate the dead time for a node based on the number of attempts.
-		/// </summary>
-		/// <param name="attempts">The number of attempts on the node</param>
-		/// <param name="minDeadTimeout">The initial dead time as configured by <see cref="ITransportConfiguration.DeadTimeout"/></param>
-		/// <param name="maxDeadTimeout">The configured maximum dead timeout as configured by <see cref="ITransportConfiguration.MaxDeadTimeout"/></param>
-		DateTime DeadTime(int attempts, TimeSpan? minDeadTimeout, TimeSpan? maxDeadTimeout);
-	}
-}
diff --git a/src/Elastic.Transport/Components/Providers/IMemoryStreamFactory.cs b/src/Elastic.Transport/Components/Providers/IMemoryStreamFactory.cs
deleted file mode 100644
index b6c71f2..0000000
--- a/src/Elastic.Transport/Components/Providers/IMemoryStreamFactory.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System.IO;
-
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// A factory for creating memory streams
-	/// </summary>
-	public interface IMemoryStreamFactory
-	{
-		/// <summary>
-		/// Creates a memory stream
-		/// </summary>
-		MemoryStream Create();
-
-		/// <summary>
-		/// Creates a memory stream with the bytes written to the stream
-		/// </summary>
-		MemoryStream Create(byte[] bytes);
-
-		/// <summary>
-		/// Creates a memory stream with the bytes written to the stream
-		/// </summary>
-		MemoryStream Create(byte[] bytes, int index, int count);
-	}
-}
diff --git a/src/Elastic.Transport/Components/Providers/IRequestPipelineFactory.cs b/src/Elastic.Transport/Components/Providers/IRequestPipelineFactory.cs
deleted file mode 100644
index 9ea2b3a..0000000
--- a/src/Elastic.Transport/Components/Providers/IRequestPipelineFactory.cs
+++ /dev/null
@@ -1,32 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-namespace Elastic.Transport
-{
-	/// <summary> A factory that creates instances of <see cref="IRequestPipeline"/>, this factory exists so that transport can be tested. </summary>
-	public interface IRequestPipelineFactory<TConfiguration>
-		where TConfiguration : class, ITransportConfiguration
-	{
-		/// <summary> Create an instance of <see cref="IRequestPipeline"/> </summary>
-		IRequestPipeline Create(TConfiguration configuration, IDateTimeProvider dateTimeProvider,
-			IMemoryStreamFactory memoryStreamFactory, IRequestParameters requestParameters
-		);
-	}
-
-	/// <summary>
-	/// The default implementation for <see cref="IRequestPipeline"/> that returns <see cref="RequestPipeline{TConfiguration}"/>
-	/// </summary>
-	internal class RequestPipelineFactory<TConfiguration> : IRequestPipelineFactory<TConfiguration>
-		where TConfiguration : class, ITransportConfiguration
-	{
-		/// <summary>
-		/// returns instances of <see cref="RequestPipeline{TConfiguration}"/>
-		/// </summary>
-		public IRequestPipeline Create(TConfiguration configurationValues, IDateTimeProvider dateTimeProvider,
-			IMemoryStreamFactory memoryStreamFactory, IRequestParameters requestParameters
-		) =>
-			new RequestPipeline<TConfiguration>(configurationValues, dateTimeProvider, memoryStreamFactory, requestParameters);
-
-	}
-}
diff --git a/src/Elastic.Transport/Components/Providers/MemoryStreamFactory.cs b/src/Elastic.Transport/Components/Providers/MemoryStreamFactory.cs
index 58b1674..c1f5785 100644
--- a/src/Elastic.Transport/Components/Providers/MemoryStreamFactory.cs
+++ b/src/Elastic.Transport/Components/Providers/MemoryStreamFactory.cs
@@ -4,23 +4,27 @@
 
 using System.IO;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A factory for creating memory streams
+/// </summary>
+public abstract class MemoryStreamFactory
 {
+	internal MemoryStreamFactory() { }
+
 	/// <summary>
-	/// A factory for creating memory streams using instances of <see cref="MemoryStream" />
+	/// Creates a memory stream
 	/// </summary>
-	public sealed class MemoryStreamFactory : IMemoryStreamFactory
-	{
-		/// <summary> Provide a static instance of this stateless class, so it can be reused</summary>
-		public static MemoryStreamFactory Default { get; } = new MemoryStreamFactory();
+	public abstract MemoryStream Create();
 
-		/// <inheritdoc />
-		public MemoryStream Create() => new();
-
-		/// <inheritdoc />
-		public MemoryStream Create(byte[] bytes) => new(bytes);
+	/// <summary>
+	/// Creates a memory stream with the bytes written to the stream
+	/// </summary>
+	public abstract MemoryStream Create(byte[] bytes);
 
-		/// <inheritdoc />
-		public MemoryStream Create(byte[] bytes, int index, int count) => new(bytes, index, count);
-	}
+	/// <summary>
+	/// Creates a memory stream with the bytes written to the stream
+	/// </summary>
+	public abstract MemoryStream Create(byte[] bytes, int index, int count);
 }
diff --git a/src/Elastic.Transport/Components/Providers/RecyclableMemoryStream.cs b/src/Elastic.Transport/Components/Providers/RecyclableMemoryStream.cs
index a169215..9f17cb3 100644
--- a/src/Elastic.Transport/Components/Providers/RecyclableMemoryStream.cs
+++ b/src/Elastic.Transport/Components/Providers/RecyclableMemoryStream.cs
@@ -33,510 +33,510 @@
 using System.IO;
 using System.Threading;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// MemoryStream implementation that deals with pooling and managing memory streams which use potentially large
+/// buffers.
+/// </summary>
+/// <remarks>
+/// This class works in tandem with the RecyclableMemoryStreamManager to supply MemoryStream
+/// objects to callers, while avoiding these specific problems:
+/// 1. LOH allocations - since all large buffers are pooled, they will never incur a Gen2 GC
+/// 2. Memory waste - A standard memory stream doubles its size when it runs out of room. This
+/// leads to continual memory growth as each stream approaches the maximum allowed size.
+/// 3. Memory copying - Each time a MemoryStream grows, all the bytes are copied into new buffers.
+/// This implementation only copies the bytes when GetBuffer is called.
+/// 4. Memory fragmentation - By using homogeneous buffer sizes, it ensures that blocks of memory
+/// can be easily reused.
+/// The stream is implemented on top of a series of uniformly-sized blocks. As the stream's length grows,
+/// additional blocks are retrieved from the memory manager. It is these blocks that are pooled, not the stream
+/// object itself.
+/// The biggest wrinkle in this implementation is when GetBuffer() is called. This requires a single
+/// contiguous buffer. If only a single block is in use, then that block is returned. If multiple blocks
+/// are in use, we retrieve a larger buffer from the memory manager. These large buffers are also pooled,
+/// split by size--they are multiples/exponentials of a chunk size (1 MB by default).
+/// Once a large buffer is assigned to the stream the blocks are NEVER again used for this stream. All operations take
+/// place on the
+/// large buffer. The large buffer can be replaced by a larger buffer from the pool as needed. All blocks and large buffers
+/// are maintained in the stream until the stream is disposed (unless AggressiveBufferReturn is enabled in the stream
+/// manager).
+/// </remarks>
+internal sealed class RecyclableMemoryStream : MemoryStream
 {
+	private const long MaxStreamLength = int.MaxValue;
+
+	private static readonly byte[] EmptyArray = new byte[0];
+
+	/// <summary>
+	/// All of these blocks must be the same size
+	/// </summary>
+	private readonly List<byte[]> _blocks = new List<byte[]>(1);
+
 	/// <summary>
-	/// MemoryStream implementation that deals with pooling and managing memory streams which use potentially large
-	/// buffers.
+	/// This buffer exists so that WriteByte can forward all of its calls to Write
+	/// without creating a new byte[] buffer on every call.
+	/// </summary>
+	private readonly byte[] _byteBuffer = new byte[1];
+
+	private readonly Guid _id;
+
+	private readonly RecyclableMemoryStreamManager _memoryManager;
+
+	private readonly string _tag;
+
+	/// <summary>
+	/// This list is used to store buffers once they're replaced by something larger.
+	/// This is for the cases where you have users of this class that may hold onto the buffers longer
+	/// than they should and you want to prevent race conditions which could corrupt the data.
+	/// </summary>
+	private List<byte[]> _dirtyBuffers;
+
+	// long to allow Interlocked.Read (for .NET Standard 1.4 compat)
+	private long _disposedState;
+
+	/// <summary>
+	/// This is only set by GetBuffer() if the necessary buffer is larger than a single block size, or on
+	/// construction if the caller immediately requests a single large buffer.
 	/// </summary>
 	/// <remarks>
-	/// This class works in tandem with the RecyclableMemoryStreamManager to supply MemoryStream
-	/// objects to callers, while avoiding these specific problems:
-	/// 1. LOH allocations - since all large buffers are pooled, they will never incur a Gen2 GC
-	/// 2. Memory waste - A standard memory stream doubles its size when it runs out of room. This
-	/// leads to continual memory growth as each stream approaches the maximum allowed size.
-	/// 3. Memory copying - Each time a MemoryStream grows, all the bytes are copied into new buffers.
-	/// This implementation only copies the bytes when GetBuffer is called.
-	/// 4. Memory fragmentation - By using homogeneous buffer sizes, it ensures that blocks of memory
-	/// can be easily reused.
-	/// The stream is implemented on top of a series of uniformly-sized blocks. As the stream's length grows,
-	/// additional blocks are retrieved from the memory manager. It is these blocks that are pooled, not the stream
-	/// object itself.
-	/// The biggest wrinkle in this implementation is when GetBuffer() is called. This requires a single
-	/// contiguous buffer. If only a single block is in use, then that block is returned. If multiple blocks
-	/// are in use, we retrieve a larger buffer from the memory manager. These large buffers are also pooled,
-	/// split by size--they are multiples/exponentials of a chunk size (1 MB by default).
-	/// Once a large buffer is assigned to the stream the blocks are NEVER again used for this stream. All operations take
-	/// place on the
-	/// large buffer. The large buffer can be replaced by a larger buffer from the pool as needed. All blocks and large buffers
-	/// are maintained in the stream until the stream is disposed (unless AggressiveBufferReturn is enabled in the stream
-	/// manager).
+	/// If this field is non-null, it contains the concatenation of the bytes found in the individual
+	/// blocks. Once it is created, this (or a larger) largeBuffer will be used for the life of the stream.
 	/// </remarks>
-	internal sealed class RecyclableMemoryStream : MemoryStream
+	private byte[] _largeBuffer;
+
+	/// <summary>
+	/// Unique identifier for this stream across it's entire lifetime
+	/// </summary>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	internal Guid Id
 	{
-		private const long MaxStreamLength = int.MaxValue;
-
-		private static readonly byte[] EmptyArray = new byte[0];
-
-		/// <summary>
-		/// All of these blocks must be the same size
-		/// </summary>
-		private readonly List<byte[]> _blocks = new List<byte[]>(1);
-
-		/// <summary>
-		/// This buffer exists so that WriteByte can forward all of its calls to Write
-		/// without creating a new byte[] buffer on every call.
-		/// </summary>
-		private readonly byte[] _byteBuffer = new byte[1];
-
-		private readonly Guid _id;
-
-		private readonly RecyclableMemoryStreamManager _memoryManager;
-
-		private readonly string _tag;
-
-		/// <summary>
-		/// This list is used to store buffers once they're replaced by something larger.
-		/// This is for the cases where you have users of this class that may hold onto the buffers longer
-		/// than they should and you want to prevent race conditions which could corrupt the data.
-		/// </summary>
-		private List<byte[]> _dirtyBuffers;
-
-		// long to allow Interlocked.Read (for .NET Standard 1.4 compat)
-		private long _disposedState;
-
-		/// <summary>
-		/// This is only set by GetBuffer() if the necessary buffer is larger than a single block size, or on
-		/// construction if the caller immediately requests a single large buffer.
-		/// </summary>
-		/// <remarks>
-		/// If this field is non-null, it contains the concatenation of the bytes found in the individual
-		/// blocks. Once it is created, this (or a larger) largeBuffer will be used for the life of the stream.
-		/// </remarks>
-		private byte[] _largeBuffer;
-
-		/// <summary>
-		/// Unique identifier for this stream across it's entire lifetime
-		/// </summary>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		internal Guid Id
+		get
 		{
-			get
-			{
-				CheckDisposed();
-				return _id;
-			}
+			CheckDisposed();
+			return _id;
 		}
+	}
 
-		/// <summary>
-		/// A temporary identifier for the current usage of this stream.
-		/// </summary>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		internal string Tag
+	/// <summary>
+	/// A temporary identifier for the current usage of this stream.
+	/// </summary>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	internal string Tag
+	{
+		get
 		{
-			get
-			{
-				CheckDisposed();
-				return _tag;
-			}
+			CheckDisposed();
+			return _tag;
 		}
+	}
 
-		/// <summary>
-		/// Gets the memory manager being used by this stream.
-		/// </summary>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		internal RecyclableMemoryStreamManager MemoryManager
+	/// <summary>
+	/// Gets the memory manager being used by this stream.
+	/// </summary>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	internal RecyclableMemoryStreamManager MemoryManager
+	{
+		get
 		{
-			get
-			{
-				CheckDisposed();
-				return _memoryManager;
-			}
+			CheckDisposed();
+			return _memoryManager;
 		}
+	}
 
-		/// <summary>
-		/// Callstack of the constructor. It is only set if MemoryManager.GenerateCallStacks is true,
-		/// which should only be in debugging situations.
-		/// </summary>
-		internal string AllocationStack { get; }
-
-		/// <summary>
-		/// Callstack of the Dispose call. It is only set if MemoryManager.GenerateCallStacks is true,
-		/// which should only be in debugging situations.
-		/// </summary>
-		internal string DisposeStack { get; private set; }
-
-		#region Constructors
-
-		/// <summary>
-		/// Allocate a new RecyclableMemoryStream object.
-		/// </summary>
-		/// <param name="memoryManager">The memory manager</param>
-		public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager)
-			: this(memoryManager, Guid.NewGuid(), null, 0, null) { }
-
-		/// <summary>
-		/// Allocate a new RecyclableMemoryStream object.
-		/// </summary>
-		/// <param name="memoryManager">The memory manager</param>
-		/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
-		public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, Guid id)
-			: this(memoryManager, id, null, 0, null) { }
-
-		/// <summary>
-		/// Allocate a new RecyclableMemoryStream object
-		/// </summary>
-		/// <param name="memoryManager">The memory manager</param>
-		/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
-		public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, string tag)
-			: this(memoryManager, Guid.NewGuid(), tag, 0, null) { }
-
-		/// <summary>
-		/// Allocate a new RecyclableMemoryStream object
-		/// </summary>
-		/// <param name="memoryManager">The memory manager</param>
-		/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
-		/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
-		public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, Guid id, string tag)
-			: this(memoryManager, id, tag, 0, null) { }
-
-		/// <summary>
-		/// Allocate a new RecyclableMemoryStream object
-		/// </summary>
-		/// <param name="memoryManager">The memory manager</param>
-		/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
-		/// <param name="requestedSize">The initial requested size to prevent future allocations</param>
-		public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, string tag, int requestedSize)
-			: this(memoryManager, Guid.NewGuid(), tag, requestedSize, null) { }
-
-		/// <summary>
-		/// Allocate a new RecyclableMemoryStream object
-		/// </summary>
-		/// <param name="memoryManager">The memory manager</param>
-		/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
-		/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
-		/// <param name="requestedSize">The initial requested size to prevent future allocations</param>
-		public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, Guid id, string tag, int requestedSize)
-			: this(memoryManager, id, tag, requestedSize, null) { }
-
-		/// <summary>
-		/// Allocate a new RecyclableMemoryStream object
-		/// </summary>
-		/// <param name="memoryManager">The memory manager</param>
-		/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
-		/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
-		/// <param name="requestedSize">The initial requested size to prevent future allocations</param>
-		/// <param name="initialLargeBuffer">
-		/// An initial buffer to use. This buffer will be owned by the stream and returned to the
-		/// memory manager upon Dispose.
-		/// </param>
-		internal RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, Guid id, string tag, int requestedSize, byte[] initialLargeBuffer
-		)
-			: base(EmptyArray)
-		{
-			_memoryManager = memoryManager;
-			_id = id;
-			_tag = tag;
+	/// <summary>
+	/// Callstack of the constructor. It is only set if MemoryManager.GenerateCallStacks is true,
+	/// which should only be in debugging situations.
+	/// </summary>
+	internal string AllocationStack { get; }
 
-			if (requestedSize < memoryManager.BlockSize) requestedSize = memoryManager.BlockSize;
+	/// <summary>
+	/// Callstack of the Dispose call. It is only set if MemoryManager.GenerateCallStacks is true,
+	/// which should only be in debugging situations.
+	/// </summary>
+	internal string DisposeStack { get; private set; }
 
-			if (initialLargeBuffer == null)
-				EnsureCapacity(requestedSize);
-			else
-				_largeBuffer = initialLargeBuffer;
+	#region Constructors
 
-			if (_memoryManager.GenerateCallStacks) AllocationStack = Environment.StackTrace;
+	/// <summary>
+	/// Allocate a new RecyclableMemoryStream object.
+	/// </summary>
+	/// <param name="memoryManager">The memory manager</param>
+	public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager)
+		: this(memoryManager, Guid.NewGuid(), null, 0, null) { }
 
-			RecyclableMemoryStreamManager.EventsWriter.MemoryStreamCreated(_id, _tag, requestedSize);
-			_memoryManager.ReportStreamCreated();
-		}
+	/// <summary>
+	/// Allocate a new RecyclableMemoryStream object.
+	/// </summary>
+	/// <param name="memoryManager">The memory manager</param>
+	/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+	public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, Guid id)
+		: this(memoryManager, id, null, 0, null) { }
 
-		#endregion
+	/// <summary>
+	/// Allocate a new RecyclableMemoryStream object
+	/// </summary>
+	/// <param name="memoryManager">The memory manager</param>
+	/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
+	public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, string tag)
+		: this(memoryManager, Guid.NewGuid(), tag, 0, null) { }
 
-		#region Dispose and Finalize
+	/// <summary>
+	/// Allocate a new RecyclableMemoryStream object
+	/// </summary>
+	/// <param name="memoryManager">The memory manager</param>
+	/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+	/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
+	public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, Guid id, string tag)
+		: this(memoryManager, id, tag, 0, null) { }
 
-		~RecyclableMemoryStream() => Dispose(false);
+	/// <summary>
+	/// Allocate a new RecyclableMemoryStream object
+	/// </summary>
+	/// <param name="memoryManager">The memory manager</param>
+	/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
+	/// <param name="requestedSize">The initial requested size to prevent future allocations</param>
+	public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, string tag, int requestedSize)
+		: this(memoryManager, Guid.NewGuid(), tag, requestedSize, null) { }
 
-		/// <summary>
-		/// Returns the memory used by this stream back to the pool.
-		/// </summary>
-		/// <param name="disposing">Whether we're disposing (true), or being called by the finalizer (false)</param>
-		[SuppressMessage("Microsoft.Usage", "CA1816:CallGCSuppressFinalizeCorrectly",
-			Justification = "We have different disposal semantics, so SuppressFinalize is in a different spot.")]
-		protected override void Dispose(bool disposing)
-		{
-			if (Interlocked.CompareExchange(ref _disposedState, 1, 0) != 0)
-			{
-				string doubleDisposeStack = null;
-				if (_memoryManager.GenerateCallStacks) doubleDisposeStack = Environment.StackTrace;
+	/// <summary>
+	/// Allocate a new RecyclableMemoryStream object
+	/// </summary>
+	/// <param name="memoryManager">The memory manager</param>
+	/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+	/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
+	/// <param name="requestedSize">The initial requested size to prevent future allocations</param>
+	public RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, Guid id, string tag, int requestedSize)
+		: this(memoryManager, id, tag, requestedSize, null) { }
 
-				RecyclableMemoryStreamManager.EventsWriter.MemoryStreamDoubleDispose(_id, _tag,
-					AllocationStack,
-					DisposeStack,
-					doubleDisposeStack);
-				return;
-			}
+	/// <summary>
+	/// Allocate a new RecyclableMemoryStream object
+	/// </summary>
+	/// <param name="memoryManager">The memory manager</param>
+	/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+	/// <param name="tag">A string identifying this stream for logging and debugging purposes</param>
+	/// <param name="requestedSize">The initial requested size to prevent future allocations</param>
+	/// <param name="initialLargeBuffer">
+	/// An initial buffer to use. This buffer will be owned by the stream and returned to the
+	/// memory manager upon Dispose.
+	/// </param>
+	internal RecyclableMemoryStream(RecyclableMemoryStreamManager memoryManager, Guid id, string tag, int requestedSize, byte[] initialLargeBuffer
+	)
+		: base(EmptyArray)
+	{
+		_memoryManager = memoryManager;
+		_id = id;
+		_tag = tag;
 
-			RecyclableMemoryStreamManager.EventsWriter.MemoryStreamDisposed(_id, _tag);
+		if (requestedSize < memoryManager.BlockSize) requestedSize = memoryManager.BlockSize;
 
-			if (_memoryManager.GenerateCallStacks) DisposeStack = Environment.StackTrace;
+		if (initialLargeBuffer == null)
+			EnsureCapacity(requestedSize);
+		else
+			_largeBuffer = initialLargeBuffer;
 
-			if (disposing)
-			{
-				_memoryManager.ReportStreamDisposed();
+		if (_memoryManager.GenerateCallStacks) AllocationStack = Environment.StackTrace;
 
-				GC.SuppressFinalize(this);
-			}
-			else
-			{
-				// We're being finalized.
+		RecyclableMemoryStreamManager.EventsWriter.MemoryStreamCreated(_id, _tag, requestedSize);
+		_memoryManager.ReportStreamCreated();
+	}
+
+	#endregion
+
+	#region Dispose and Finalize
 
-				RecyclableMemoryStreamManager.EventsWriter.MemoryStreamFinalized(_id, _tag, AllocationStack);
+	~RecyclableMemoryStream() => Dispose(false);
+
+	/// <summary>
+	/// Returns the memory used by this stream back to the pool.
+	/// </summary>
+	/// <param name="disposing">Whether we're disposing (true), or being called by the finalizer (false)</param>
+	[SuppressMessage("Microsoft.Usage", "CA1816:CallGCSuppressFinalizeCorrectly",
+		Justification = "We have different disposal semantics, so SuppressFinalize is in a different spot.")]
+	protected override void Dispose(bool disposing)
+	{
+		if (Interlocked.CompareExchange(ref _disposedState, 1, 0) != 0)
+		{
+			string doubleDisposeStack = null;
+			if (_memoryManager.GenerateCallStacks) doubleDisposeStack = Environment.StackTrace;
+
+			RecyclableMemoryStreamManager.EventsWriter.MemoryStreamDoubleDispose(_id, _tag,
+				AllocationStack,
+				DisposeStack,
+				doubleDisposeStack);
+			return;
+		}
+
+		RecyclableMemoryStreamManager.EventsWriter.MemoryStreamDisposed(_id, _tag);
+
+		if (_memoryManager.GenerateCallStacks) DisposeStack = Environment.StackTrace;
+
+		if (disposing)
+		{
+			_memoryManager.ReportStreamDisposed();
+
+			GC.SuppressFinalize(this);
+		}
+		else
+		{
+			// We're being finalized.
+
+			RecyclableMemoryStreamManager.EventsWriter.MemoryStreamFinalized(_id, _tag, AllocationStack);
 
 #if !NETSTANDARD1_4
-				if (AppDomain.CurrentDomain.IsFinalizingForUnload())
-				{
-					// If we're being finalized because of a shutdown, don't go any further.
-					// We have no idea what's already been cleaned up. Triggering events may cause
-					// a crash.
-					base.Dispose(false);
-					return;
-				}
+			if (AppDomain.CurrentDomain.IsFinalizingForUnload())
+			{
+				// If we're being finalized because of a shutdown, don't go any further.
+				// We have no idea what's already been cleaned up. Triggering events may cause
+				// a crash.
+				base.Dispose(false);
+				return;
+			}
 #endif
 
-				_memoryManager.ReportStreamFinalized();
-			}
+			_memoryManager.ReportStreamFinalized();
+		}
 
-			_memoryManager.ReportStreamLength(_length);
+		_memoryManager.ReportStreamLength(_length);
 
-			if (_largeBuffer != null) _memoryManager.ReturnLargeBuffer(_largeBuffer, _tag);
+		if (_largeBuffer != null) _memoryManager.ReturnLargeBuffer(_largeBuffer, _tag);
 
-			if (_dirtyBuffers != null)
-				foreach (var buffer in _dirtyBuffers)
-					_memoryManager.ReturnLargeBuffer(buffer, _tag);
+		if (_dirtyBuffers != null)
+			foreach (var buffer in _dirtyBuffers)
+				_memoryManager.ReturnLargeBuffer(buffer, _tag);
 
-			_memoryManager.ReturnBlocks(_blocks, _tag);
-			_blocks.Clear();
+		_memoryManager.ReturnBlocks(_blocks, _tag);
+		_blocks.Clear();
 
-			base.Dispose(disposing);
-		}
+		base.Dispose(disposing);
+	}
 
-		/// <summary>
-		/// Equivalent to Dispose
-		/// </summary>
+	/// <summary>
+	/// Equivalent to Dispose
+	/// </summary>
 #if NETSTANDARD1_4
         public void Close() => Dispose(true);
 #else
-		public override void Close() => Dispose(true);
+	public override void Close() => Dispose(true);
 #endif
 
 #endregion
 
-		#region MemoryStream overrides
-
-		/// <summary>
-		/// Gets or sets the capacity
-		/// </summary>
-		/// <remarks>
-		/// Capacity is always in multiples of the memory manager's block size, unless
-		/// the large buffer is in use.  Capacity never decreases during a stream's lifetime.
-		/// Explicitly setting the capacity to a lower value than the current value will have no effect.
-		/// This is because the buffers are all pooled by chunks and there's little reason to
-		/// allow stream truncation.
-		/// </remarks>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public override int Capacity
+	#region MemoryStream overrides
+
+	/// <summary>
+	/// Gets or sets the capacity
+	/// </summary>
+	/// <remarks>
+	/// Capacity is always in multiples of the memory manager's block size, unless
+	/// the large buffer is in use.  Capacity never decreases during a stream's lifetime.
+	/// Explicitly setting the capacity to a lower value than the current value will have no effect.
+	/// This is because the buffers are all pooled by chunks and there's little reason to
+	/// allow stream truncation.
+	/// </remarks>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public override int Capacity
+	{
+		get
 		{
-			get
-			{
-				CheckDisposed();
-				if (_largeBuffer != null) return _largeBuffer.Length;
+			CheckDisposed();
+			if (_largeBuffer != null) return _largeBuffer.Length;
 
-				var size = (long)_blocks.Count * _memoryManager.BlockSize;
-				return (int)Math.Min(int.MaxValue, size);
-			}
-			set
-			{
-				CheckDisposed();
-				EnsureCapacity(value);
-			}
+			var size = (long)_blocks.Count * _memoryManager.BlockSize;
+			return (int)Math.Min(int.MaxValue, size);
+		}
+		set
+		{
+			CheckDisposed();
+			EnsureCapacity(value);
 		}
+	}
 
-		private int _length;
+	private int _length;
 
-		/// <summary>
-		/// Gets the number of bytes written to this stream.
-		/// </summary>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public override long Length
+	/// <summary>
+	/// Gets the number of bytes written to this stream.
+	/// </summary>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public override long Length
+	{
+		get
 		{
-			get
-			{
-				CheckDisposed();
-				return _length;
-			}
+			CheckDisposed();
+			return _length;
 		}
+	}
 
-		private int _position;
+	private int _position;
 
-		/// <summary>
-		/// Gets the current position in the stream
-		/// </summary>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public override long Position
+	/// <summary>
+	/// Gets the current position in the stream
+	/// </summary>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public override long Position
+	{
+		get
 		{
-			get
-			{
-				CheckDisposed();
-				return _position;
-			}
-			set
-			{
-				CheckDisposed();
-				if (value < 0) throw new ArgumentOutOfRangeException("value", "value must be non-negative");
+			CheckDisposed();
+			return _position;
+		}
+		set
+		{
+			CheckDisposed();
+			if (value < 0) throw new ArgumentOutOfRangeException("value", "value must be non-negative");
 
-				if (value > MaxStreamLength) throw new ArgumentOutOfRangeException("value", "value cannot be more than " + MaxStreamLength);
+			if (value > MaxStreamLength) throw new ArgumentOutOfRangeException("value", "value cannot be more than " + MaxStreamLength);
 
-				_position = (int)value;
-			}
+			_position = (int)value;
 		}
+	}
+
+	/// <summary>
+	/// Whether the stream can currently read
+	/// </summary>
+	public override bool CanRead => !Disposed;
+
+	/// <summary>
+	/// Whether the stream can currently seek
+	/// </summary>
+	public override bool CanSeek => !Disposed;
+
+	/// <summary>
+	/// Always false
+	/// </summary>
+	public override bool CanTimeout => false;
+
+	/// <summary>
+	/// Whether the stream can currently write
+	/// </summary>
+	public override bool CanWrite => !Disposed;
 
-		/// <summary>
-		/// Whether the stream can currently read
-		/// </summary>
-		public override bool CanRead => !Disposed;
-
-		/// <summary>
-		/// Whether the stream can currently seek
-		/// </summary>
-		public override bool CanSeek => !Disposed;
-
-		/// <summary>
-		/// Always false
-		/// </summary>
-		public override bool CanTimeout => false;
-
-		/// <summary>
-		/// Whether the stream can currently write
-		/// </summary>
-		public override bool CanWrite => !Disposed;
-
-		/// <summary>
-		/// Returns a single buffer containing the contents of the stream.
-		/// The buffer may be longer than the stream length.
-		/// </summary>
-		/// <returns>A byte[] buffer</returns>
-		/// <remarks>
-		/// IMPORTANT: Doing a Write() after calling GetBuffer() invalidates the buffer. The old buffer is held onto
-		/// until Dispose is called, but the next time GetBuffer() is called, a new buffer from the pool will be required.
-		/// </remarks>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	/// <summary>
+	/// Returns a single buffer containing the contents of the stream.
+	/// The buffer may be longer than the stream length.
+	/// </summary>
+	/// <returns>A byte[] buffer</returns>
+	/// <remarks>
+	/// IMPORTANT: Doing a Write() after calling GetBuffer() invalidates the buffer. The old buffer is held onto
+	/// until Dispose is called, but the next time GetBuffer() is called, a new buffer from the pool will be required.
+	/// </remarks>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
 #if NETSTANDARD1_4
         public byte[] GetBuffer()
 #else
-		public override byte[] GetBuffer()
+	public override byte[] GetBuffer()
 #endif
-		{
-			CheckDisposed();
-
-			if (_largeBuffer != null) return _largeBuffer;
+	{
+		CheckDisposed();
 
-			if (_blocks.Count == 1) return _blocks[0];
+		if (_largeBuffer != null) return _largeBuffer;
 
-			// Buffer needs to reflect the capacity, not the length, because
-			// it's possible that people will manipulate the buffer directly
-			// and set the length afterward. Capacity sets the expectation
-			// for the size of the buffer.
-			var newBuffer = _memoryManager.GetLargeBuffer(Capacity, _tag);
+		if (_blocks.Count == 1) return _blocks[0];
 
-			// InternalRead will check for existence of largeBuffer, so make sure we
-			// don't set it until after we've copied the data.
-			InternalRead(newBuffer, 0, _length, 0);
-			_largeBuffer = newBuffer;
+		// Buffer needs to reflect the capacity, not the length, because
+		// it's possible that people will manipulate the buffer directly
+		// and set the length afterward. Capacity sets the expectation
+		// for the size of the buffer.
+		var newBuffer = _memoryManager.GetLargeBuffer(Capacity, _tag);
 
-			if (_blocks.Count > 0 && _memoryManager.AggressiveBufferReturn)
-			{
-				_memoryManager.ReturnBlocks(_blocks, _tag);
-				_blocks.Clear();
-			}
+		// InternalRead will check for existence of largeBuffer, so make sure we
+		// don't set it until after we've copied the data.
+		InternalRead(newBuffer, 0, _length, 0);
+		_largeBuffer = newBuffer;
 
-			return _largeBuffer;
+		if (_blocks.Count > 0 && _memoryManager.AggressiveBufferReturn)
+		{
+			_memoryManager.ReturnBlocks(_blocks, _tag);
+			_blocks.Clear();
 		}
 
-		/// <summary>
-		/// Returns an ArraySegment that wraps a single buffer containing the contents of the stream.
-		/// </summary>
-		/// <param name="buffer">An ArraySegment containing a reference to the underlying bytes.</param>
-		/// <returns>Always returns true.</returns>
-		/// <remarks>
-		/// GetBuffer has no failure modes (it always returns something, even if it's an empty buffer), therefore this method
-		/// always returns a valid ArraySegment to the same buffer returned by GetBuffer.
-		/// </remarks>
+		return _largeBuffer;
+	}
+
+	/// <summary>
+	/// Returns an ArraySegment that wraps a single buffer containing the contents of the stream.
+	/// </summary>
+	/// <param name="buffer">An ArraySegment containing a reference to the underlying bytes.</param>
+	/// <returns>Always returns true.</returns>
+	/// <remarks>
+	/// GetBuffer has no failure modes (it always returns something, even if it's an empty buffer), therefore this method
+	/// always returns a valid ArraySegment to the same buffer returned by GetBuffer.
+	/// </remarks>
 #if NET40 || NET45
         public bool TryGetBuffer(out ArraySegment<byte> buffer)
 #else
-		public override bool TryGetBuffer(out ArraySegment<byte> buffer)
+	public override bool TryGetBuffer(out ArraySegment<byte> buffer)
 #endif
-		{
-			CheckDisposed();
-			buffer = new ArraySegment<byte>(GetBuffer(), 0, (int)Length);
-			// GetBuffer has no failure modes, so this should always succeed
-			return true;
-		}
+	{
+		CheckDisposed();
+		buffer = new ArraySegment<byte>(GetBuffer(), 0, (int)Length);
+		// GetBuffer has no failure modes, so this should always succeed
+		return true;
+	}
 
-		/// <summary>
-		/// Returns a new array with a copy of the buffer's contents. You should almost certainly be using GetBuffer combined with
-		/// the Length to
-		/// access the bytes in this stream. Calling ToArray will destroy the benefits of pooled buffers, but it is included
-		/// for the sake of completeness.
-		/// </summary>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	/// <summary>
+	/// Returns a new array with a copy of the buffer's contents. You should almost certainly be using GetBuffer combined with
+	/// the Length to
+	/// access the bytes in this stream. Calling ToArray will destroy the benefits of pooled buffers, but it is included
+	/// for the sake of completeness.
+	/// </summary>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
 #pragma warning disable CS0809
-		[Obsolete("This method has degraded performance vs. GetBuffer and should be avoided.")]
-		public override byte[] ToArray()
-		{
-			CheckDisposed();
-			var newBuffer = new byte[Length];
+	[Obsolete("This method has degraded performance vs. GetBuffer and should be avoided.")]
+	public override byte[] ToArray()
+	{
+		CheckDisposed();
+		var newBuffer = new byte[Length];
 
-			InternalRead(newBuffer, 0, _length, 0);
-			var stack = _memoryManager.GenerateCallStacks ? Environment.StackTrace : null;
-			RecyclableMemoryStreamManager.EventsWriter.MemoryStreamToArray(_id, _tag, stack, 0);
-			_memoryManager.ReportStreamToArray();
+		InternalRead(newBuffer, 0, _length, 0);
+		var stack = _memoryManager.GenerateCallStacks ? Environment.StackTrace : null;
+		RecyclableMemoryStreamManager.EventsWriter.MemoryStreamToArray(_id, _tag, stack, 0);
+		_memoryManager.ReportStreamToArray();
 
-			return newBuffer;
-		}
+		return newBuffer;
+	}
 #pragma warning restore CS0809
 
-		/// <summary>
-		/// Reads from the current position into the provided buffer
-		/// </summary>
-		/// <param name="buffer">Destination buffer</param>
-		/// <param name="offset">Offset into buffer at which to start placing the read bytes.</param>
-		/// <param name="count">Number of bytes to read.</param>
-		/// <returns>The number of bytes read</returns>
-		/// <exception cref="ArgumentNullException">buffer is null</exception>
-		/// <exception cref="ArgumentOutOfRangeException">offset or count is less than 0</exception>
-		/// <exception cref="ArgumentException">offset subtracted from the buffer length is less than count</exception>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public override int Read(byte[] buffer, int offset, int count) => SafeRead(buffer, offset, count, ref _position);
-
-		/// <summary>
-		/// Reads from the specified position into the provided buffer
-		/// </summary>
-		/// <param name="buffer">Destination buffer</param>
-		/// <param name="offset">Offset into buffer at which to start placing the read bytes.</param>
-		/// <param name="count">Number of bytes to read.</param>
-		/// <param name="streamPosition">Position in the stream to start reading from</param>
-		/// <returns>The number of bytes read</returns>
-		/// <exception cref="ArgumentNullException">buffer is null</exception>
-		/// <exception cref="ArgumentOutOfRangeException">offset or count is less than 0</exception>
-		/// <exception cref="ArgumentException">offset subtracted from the buffer length is less than count</exception>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public int SafeRead(byte[] buffer, int offset, int count, ref int streamPosition)
-		{
-			CheckDisposed();
-			if (buffer == null) throw new ArgumentNullException(nameof(buffer));
+	/// <summary>
+	/// Reads from the current position into the provided buffer
+	/// </summary>
+	/// <param name="buffer">Destination buffer</param>
+	/// <param name="offset">Offset into buffer at which to start placing the read bytes.</param>
+	/// <param name="count">Number of bytes to read.</param>
+	/// <returns>The number of bytes read</returns>
+	/// <exception cref="ArgumentNullException">buffer is null</exception>
+	/// <exception cref="ArgumentOutOfRangeException">offset or count is less than 0</exception>
+	/// <exception cref="ArgumentException">offset subtracted from the buffer length is less than count</exception>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public override int Read(byte[] buffer, int offset, int count) => SafeRead(buffer, offset, count, ref _position);
 
-			if (offset < 0) throw new ArgumentOutOfRangeException(nameof(offset), "offset cannot be negative");
+	/// <summary>
+	/// Reads from the specified position into the provided buffer
+	/// </summary>
+	/// <param name="buffer">Destination buffer</param>
+	/// <param name="offset">Offset into buffer at which to start placing the read bytes.</param>
+	/// <param name="count">Number of bytes to read.</param>
+	/// <param name="streamPosition">Position in the stream to start reading from</param>
+	/// <returns>The number of bytes read</returns>
+	/// <exception cref="ArgumentNullException">buffer is null</exception>
+	/// <exception cref="ArgumentOutOfRangeException">offset or count is less than 0</exception>
+	/// <exception cref="ArgumentException">offset subtracted from the buffer length is less than count</exception>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public int SafeRead(byte[] buffer, int offset, int count, ref int streamPosition)
+	{
+		CheckDisposed();
+		if (buffer == null) throw new ArgumentNullException(nameof(buffer));
 
-			if (count < 0) throw new ArgumentOutOfRangeException(nameof(count), "count cannot be negative");
+		if (offset < 0) throw new ArgumentOutOfRangeException(nameof(offset), "offset cannot be negative");
 
-			if (offset + count > buffer.Length) throw new ArgumentException("buffer length must be at least offset + count");
+		if (count < 0) throw new ArgumentOutOfRangeException(nameof(count), "count cannot be negative");
 
-			var amountRead = InternalRead(buffer, offset, count, streamPosition);
-			streamPosition += amountRead;
-			return amountRead;
-		}
+		if (offset + count > buffer.Length) throw new ArgumentException("buffer length must be at least offset + count");
+
+		var amountRead = InternalRead(buffer, offset, count, streamPosition);
+		streamPosition += amountRead;
+		return amountRead;
+	}
 
 #if NETCOREAPP2_1 || NETSTANDARD2_1
         /// <summary>
@@ -547,7 +547,7 @@ public int SafeRead(byte[] buffer, int offset, int count, ref int streamPosition
         /// <exception cref="ObjectDisposedException">Object has been disposed</exception>
         public override int Read(Span<byte> buffer) => SafeRead(buffer, ref _position);
 
-		/// <summary>
+	/// <summary>
         /// Reads from the specified position into the provided buffer
         /// </summary>
         /// <param name="buffer">Destination buffer</param>
@@ -564,63 +564,63 @@ public int SafeRead(Span<byte> buffer, ref int streamPosition)
         }
 #endif
 
-		/// <summary>
-		/// Writes the buffer to the stream
-		/// </summary>
-		/// <param name="buffer">Source buffer</param>
-		/// <param name="offset">Start position</param>
-		/// <param name="count">Number of bytes to write</param>
-		/// <exception cref="ArgumentNullException">buffer is null</exception>
-		/// <exception cref="ArgumentOutOfRangeException">offset or count is negative</exception>
-		/// <exception cref="ArgumentException">buffer.Length - offset is not less than count</exception>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public override void Write(byte[] buffer, int offset, int count)
-		{
-			CheckDisposed();
-			if (buffer == null) throw new ArgumentNullException(nameof(buffer));
+	/// <summary>
+	/// Writes the buffer to the stream
+	/// </summary>
+	/// <param name="buffer">Source buffer</param>
+	/// <param name="offset">Start position</param>
+	/// <param name="count">Number of bytes to write</param>
+	/// <exception cref="ArgumentNullException">buffer is null</exception>
+	/// <exception cref="ArgumentOutOfRangeException">offset or count is negative</exception>
+	/// <exception cref="ArgumentException">buffer.Length - offset is not less than count</exception>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public override void Write(byte[] buffer, int offset, int count)
+	{
+		CheckDisposed();
+		if (buffer == null) throw new ArgumentNullException(nameof(buffer));
 
-			if (offset < 0)
-				throw new ArgumentOutOfRangeException(nameof(offset), offset,
-					"Offset must be in the range of 0 - buffer.Length-1");
+		if (offset < 0)
+			throw new ArgumentOutOfRangeException(nameof(offset), offset,
+				"Offset must be in the range of 0 - buffer.Length-1");
 
-			if (count < 0) throw new ArgumentOutOfRangeException(nameof(count), count, "count must be non-negative");
+		if (count < 0) throw new ArgumentOutOfRangeException(nameof(count), count, "count must be non-negative");
 
-			if (count + offset > buffer.Length) throw new ArgumentException("count must be greater than buffer.Length - offset");
+		if (count + offset > buffer.Length) throw new ArgumentException("count must be greater than buffer.Length - offset");
 
-			var blockSize = _memoryManager.BlockSize;
-			var end = (long)_position + count;
-			// Check for overflow
-			if (end > MaxStreamLength) throw new IOException("Maximum capacity exceeded");
+		var blockSize = _memoryManager.BlockSize;
+		var end = (long)_position + count;
+		// Check for overflow
+		if (end > MaxStreamLength) throw new IOException("Maximum capacity exceeded");
 
-			EnsureCapacity((int)end);
+		EnsureCapacity((int)end);
 
-			if (_largeBuffer == null)
-			{
-				var bytesRemaining = count;
-				var bytesWritten = 0;
-				var blockAndOffset = GetBlockAndRelativeOffset(_position);
+		if (_largeBuffer == null)
+		{
+			var bytesRemaining = count;
+			var bytesWritten = 0;
+			var blockAndOffset = GetBlockAndRelativeOffset(_position);
 
-				while (bytesRemaining > 0)
-				{
-					var currentBlock = _blocks[blockAndOffset.Block];
-					var remainingInBlock = blockSize - blockAndOffset.Offset;
-					var amountToWriteInBlock = Math.Min(remainingInBlock, bytesRemaining);
+			while (bytesRemaining > 0)
+			{
+				var currentBlock = _blocks[blockAndOffset.Block];
+				var remainingInBlock = blockSize - blockAndOffset.Offset;
+				var amountToWriteInBlock = Math.Min(remainingInBlock, bytesRemaining);
 
-					Buffer.BlockCopy(buffer, offset + bytesWritten, currentBlock, blockAndOffset.Offset,
-						amountToWriteInBlock);
+				Buffer.BlockCopy(buffer, offset + bytesWritten, currentBlock, blockAndOffset.Offset,
+					amountToWriteInBlock);
 
-					bytesRemaining -= amountToWriteInBlock;
-					bytesWritten += amountToWriteInBlock;
+				bytesRemaining -= amountToWriteInBlock;
+				bytesWritten += amountToWriteInBlock;
 
-					++blockAndOffset.Block;
-					blockAndOffset.Offset = 0;
-				}
+				++blockAndOffset.Block;
+				blockAndOffset.Offset = 0;
 			}
-			else
-				Buffer.BlockCopy(buffer, offset, _largeBuffer, _position, count);
-			_position = (int)end;
-			_length = Math.Max(_position, _length);
 		}
+		else
+			Buffer.BlockCopy(buffer, offset, _largeBuffer, _position, count);
+		_position = (int)end;
+		_length = Math.Max(_position, _length);
+	}
 
 #if NETCOREAPP2_1 || NETSTANDARD2_1
         /// <summary>
@@ -638,7 +638,7 @@ public override void Write(ReadOnlySpan<byte> source)
             // Check for overflow
             if (end > MaxStreamLength) throw new IOException("Maximum capacity exceeded");
 
-			EnsureCapacity((int)end);
+		EnsureCapacity((int)end);
 
             if (_largeBuffer == null)
             {
@@ -660,191 +660,191 @@ public override void Write(ReadOnlySpan<byte> source)
                 }
             }
             else
-				source.CopyTo(_largeBuffer.AsSpan(_position));
-			_position = (int)end;
+			source.CopyTo(_largeBuffer.AsSpan(_position));
+		_position = (int)end;
             _length = Math.Max(_position, _length);
         }
 #endif
 
-		/// <summary>
-		/// Returns a useful string for debugging. This should not normally be called in actual production code.
-		/// </summary>
-		public override string ToString() => $"Id = {Id}, Tag = {Tag}, Length = {Length:N0} bytes";
-
-		/// <summary>
-		/// Writes a single byte to the current position in the stream.
-		/// </summary>
-		/// <param name="value">byte value to write</param>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public override void WriteByte(byte value)
-		{
-			CheckDisposed();
-			_byteBuffer[0] = value;
-			Write(_byteBuffer, 0, 1);
-		}
+	/// <summary>
+	/// Returns a useful string for debugging. This should not normally be called in actual production code.
+	/// </summary>
+	public override string ToString() => $"Id = {Id}, Tag = {Tag}, Length = {Length:N0} bytes";
 
-		/// <summary>
-		/// Reads a single byte from the current position in the stream.
-		/// </summary>
-		/// <returns>The byte at the current position, or -1 if the position is at the end of the stream.</returns>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public override int ReadByte() => SafeReadByte(ref _position);
-
-		/// <summary>
-		/// Reads a single byte from the specified position in the stream.
-		/// </summary>
-		/// <param name="streamPosition">The position in the stream to read from</param>
-		/// <returns>The byte at the current position, or -1 if the position is at the end of the stream.</returns>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public int SafeReadByte(ref int streamPosition)
-		{
-			CheckDisposed();
-			if (streamPosition == _length) return -1;
+	/// <summary>
+	/// Writes a single byte to the current position in the stream.
+	/// </summary>
+	/// <param name="value">byte value to write</param>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public override void WriteByte(byte value)
+	{
+		CheckDisposed();
+		_byteBuffer[0] = value;
+		Write(_byteBuffer, 0, 1);
+	}
 
-			byte value;
-			if (_largeBuffer == null)
-			{
-				var blockAndOffset = GetBlockAndRelativeOffset(streamPosition);
-				value = _blocks[blockAndOffset.Block][blockAndOffset.Offset];
-			}
-			else
-				value = _largeBuffer[streamPosition];
-			streamPosition++;
-			return value;
-		}
+	/// <summary>
+	/// Reads a single byte from the current position in the stream.
+	/// </summary>
+	/// <returns>The byte at the current position, or -1 if the position is at the end of the stream.</returns>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public override int ReadByte() => SafeReadByte(ref _position);
+
+	/// <summary>
+	/// Reads a single byte from the specified position in the stream.
+	/// </summary>
+	/// <param name="streamPosition">The position in the stream to read from</param>
+	/// <returns>The byte at the current position, or -1 if the position is at the end of the stream.</returns>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public int SafeReadByte(ref int streamPosition)
+	{
+		CheckDisposed();
+		if (streamPosition == _length) return -1;
 
-		/// <summary>
-		/// Sets the length of the stream
-		/// </summary>
-		/// <exception cref="ArgumentOutOfRangeException">value is negative or larger than MaxStreamLength</exception>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		public override void SetLength(long value)
+		byte value;
+		if (_largeBuffer == null)
 		{
-			CheckDisposed();
-			if (value < 0 || value > MaxStreamLength)
-				throw new ArgumentOutOfRangeException(nameof(value),
-					"value must be non-negative and at most " + MaxStreamLength);
+			var blockAndOffset = GetBlockAndRelativeOffset(streamPosition);
+			value = _blocks[blockAndOffset.Block][blockAndOffset.Offset];
+		}
+		else
+			value = _largeBuffer[streamPosition];
+		streamPosition++;
+		return value;
+	}
 
-			EnsureCapacity((int)value);
+	/// <summary>
+	/// Sets the length of the stream
+	/// </summary>
+	/// <exception cref="ArgumentOutOfRangeException">value is negative or larger than MaxStreamLength</exception>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	public override void SetLength(long value)
+	{
+		CheckDisposed();
+		if (value < 0 || value > MaxStreamLength)
+			throw new ArgumentOutOfRangeException(nameof(value),
+				"value must be non-negative and at most " + MaxStreamLength);
 
-			_length = (int)value;
-			if (_position > value) _position = (int)value;
-		}
+		EnsureCapacity((int)value);
 
-		/// <summary>
-		/// Sets the position to the offset from the seek location
-		/// </summary>
-		/// <param name="offset">How many bytes to move</param>
-		/// <param name="loc">From where</param>
-		/// <returns>The new position</returns>
-		/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
-		/// <exception cref="ArgumentOutOfRangeException">offset is larger than MaxStreamLength</exception>
-		/// <exception cref="ArgumentException">Invalid seek origin</exception>
-		/// <exception cref="IOException">Attempt to set negative position</exception>
-		public override long Seek(long offset, SeekOrigin loc)
-		{
-			CheckDisposed();
-			if (offset > MaxStreamLength) throw new ArgumentOutOfRangeException(nameof(offset), "offset cannot be larger than " + MaxStreamLength);
+		_length = (int)value;
+		if (_position > value) _position = (int)value;
+	}
 
-			int newPosition;
-			switch (loc)
-			{
-				case SeekOrigin.Begin:
-					newPosition = (int)offset;
-					break;
-				case SeekOrigin.Current:
-					newPosition = (int)offset + _position;
-					break;
-				case SeekOrigin.End:
-					newPosition = (int)offset + _length;
-					break;
-				default:
-					throw new ArgumentException("Invalid seek origin", nameof(loc));
-			}
-			if (newPosition < 0) throw new IOException("Seek before beginning");
+	/// <summary>
+	/// Sets the position to the offset from the seek location
+	/// </summary>
+	/// <param name="offset">How many bytes to move</param>
+	/// <param name="loc">From where</param>
+	/// <returns>The new position</returns>
+	/// <exception cref="ObjectDisposedException">Object has been disposed</exception>
+	/// <exception cref="ArgumentOutOfRangeException">offset is larger than MaxStreamLength</exception>
+	/// <exception cref="ArgumentException">Invalid seek origin</exception>
+	/// <exception cref="IOException">Attempt to set negative position</exception>
+	public override long Seek(long offset, SeekOrigin loc)
+	{
+		CheckDisposed();
+		if (offset > MaxStreamLength) throw new ArgumentOutOfRangeException(nameof(offset), "offset cannot be larger than " + MaxStreamLength);
 
-			_position = newPosition;
-			return _position;
+		int newPosition;
+		switch (loc)
+		{
+			case SeekOrigin.Begin:
+				newPosition = (int)offset;
+				break;
+			case SeekOrigin.Current:
+				newPosition = (int)offset + _position;
+				break;
+			case SeekOrigin.End:
+				newPosition = (int)offset + _length;
+				break;
+			default:
+				throw new ArgumentException("Invalid seek origin", nameof(loc));
 		}
+		if (newPosition < 0) throw new IOException("Seek before beginning");
 
-		/// <summary>
-		/// Synchronously writes this stream's bytes to the parameter stream.
-		/// </summary>
-		/// <param name="stream">Destination stream</param>
-		/// <remarks>Important: This does a synchronous write, which may not be desired in some situations</remarks>
-		public override void WriteTo(Stream stream)
+		_position = newPosition;
+		return _position;
+	}
+
+	/// <summary>
+	/// Synchronously writes this stream's bytes to the parameter stream.
+	/// </summary>
+	/// <param name="stream">Destination stream</param>
+	/// <remarks>Important: This does a synchronous write, which may not be desired in some situations</remarks>
+	public override void WriteTo(Stream stream)
+	{
+		CheckDisposed();
+		if (stream == null) throw new ArgumentNullException(nameof(stream));
+
+		if (_largeBuffer == null)
 		{
-			CheckDisposed();
-			if (stream == null) throw new ArgumentNullException(nameof(stream));
+			var currentBlock = 0;
+			var bytesRemaining = _length;
 
-			if (_largeBuffer == null)
+			while (bytesRemaining > 0)
 			{
-				var currentBlock = 0;
-				var bytesRemaining = _length;
-
-				while (bytesRemaining > 0)
-				{
-					var amountToCopy = Math.Min(_blocks[currentBlock].Length, bytesRemaining);
-					stream.Write(_blocks[currentBlock], 0, amountToCopy);
+				var amountToCopy = Math.Min(_blocks[currentBlock].Length, bytesRemaining);
+				stream.Write(_blocks[currentBlock], 0, amountToCopy);
 
-					bytesRemaining -= amountToCopy;
+				bytesRemaining -= amountToCopy;
 
-					++currentBlock;
-				}
+				++currentBlock;
 			}
-			else
-				stream.Write(_largeBuffer, 0, _length);
 		}
+		else
+			stream.Write(_largeBuffer, 0, _length);
+	}
 
-		#endregion
+	#endregion
 
-		#region Helper Methods
+	#region Helper Methods
 
-		private bool Disposed => Interlocked.Read(ref _disposedState) != 0;
+	private bool Disposed => Interlocked.Read(ref _disposedState) != 0;
 
-		private void CheckDisposed()
-		{
-			if (Disposed) throw new ObjectDisposedException($"The stream with Id {_id} and Tag {_tag} is disposed.");
-		}
+	private void CheckDisposed()
+	{
+		if (Disposed) throw new ObjectDisposedException($"The stream with Id {_id} and Tag {_tag} is disposed.");
+	}
 
-		private int InternalRead(byte[] buffer, int offset, int count, int fromPosition)
-		{
-			if (_length - fromPosition <= 0) return 0;
+	private int InternalRead(byte[] buffer, int offset, int count, int fromPosition)
+	{
+		if (_length - fromPosition <= 0) return 0;
 
-			int amountToCopy;
+		int amountToCopy;
+
+		if (_largeBuffer == null)
+		{
+			var blockAndOffset = GetBlockAndRelativeOffset(fromPosition);
+			var bytesWritten = 0;
+			var bytesRemaining = Math.Min(count, _length - fromPosition);
 
-			if (_largeBuffer == null)
+			while (bytesRemaining > 0)
 			{
-				var blockAndOffset = GetBlockAndRelativeOffset(fromPosition);
-				var bytesWritten = 0;
-				var bytesRemaining = Math.Min(count, _length - fromPosition);
-
-				while (bytesRemaining > 0)
-				{
-					amountToCopy = Math.Min(_blocks[blockAndOffset.Block].Length - blockAndOffset.Offset,
-						bytesRemaining);
-					Buffer.BlockCopy(_blocks[blockAndOffset.Block], blockAndOffset.Offset, buffer,
-						bytesWritten + offset, amountToCopy);
-
-					bytesWritten += amountToCopy;
-					bytesRemaining -= amountToCopy;
-
-					++blockAndOffset.Block;
-					blockAndOffset.Offset = 0;
-				}
-				return bytesWritten;
+				amountToCopy = Math.Min(_blocks[blockAndOffset.Block].Length - blockAndOffset.Offset,
+					bytesRemaining);
+				Buffer.BlockCopy(_blocks[blockAndOffset.Block], blockAndOffset.Offset, buffer,
+					bytesWritten + offset, amountToCopy);
+
+				bytesWritten += amountToCopy;
+				bytesRemaining -= amountToCopy;
+
+				++blockAndOffset.Block;
+				blockAndOffset.Offset = 0;
 			}
-			amountToCopy = Math.Min(count, _length - fromPosition);
-			Buffer.BlockCopy(_largeBuffer, fromPosition, buffer, offset, amountToCopy);
-			return amountToCopy;
+			return bytesWritten;
 		}
+		amountToCopy = Math.Min(count, _length - fromPosition);
+		Buffer.BlockCopy(_largeBuffer, fromPosition, buffer, offset, amountToCopy);
+		return amountToCopy;
+	}
 
 #if NETCOREAPP2_1 || NETSTANDARD2_1
         private int InternalRead(Span<byte> buffer, int fromPosition)
         {
             if (_length - fromPosition <= 0) return 0;
 
-			int amountToCopy;
+		int amountToCopy;
 
             if (_largeBuffer == null)
             {
@@ -873,69 +873,68 @@ private int InternalRead(Span<byte> buffer, int fromPosition)
         }
 #endif
 
-		private struct BlockAndOffset
-		{
-			public int Block;
-			public int Offset;
+	private struct BlockAndOffset
+	{
+		public int Block;
+		public int Offset;
 
-			public BlockAndOffset(int block, int offset)
-			{
-				Block = block;
-				Offset = offset;
-			}
+		public BlockAndOffset(int block, int offset)
+		{
+			Block = block;
+			Offset = offset;
 		}
+	}
+
+	private BlockAndOffset GetBlockAndRelativeOffset(int offset)
+	{
+		var blockSize = _memoryManager.BlockSize;
+		return new BlockAndOffset(offset / blockSize, offset % blockSize);
+	}
 
-		private BlockAndOffset GetBlockAndRelativeOffset(int offset)
+	private void EnsureCapacity(int newCapacity)
+	{
+		if (newCapacity > _memoryManager.MaximumStreamCapacity && _memoryManager.MaximumStreamCapacity > 0)
 		{
-			var blockSize = _memoryManager.BlockSize;
-			return new BlockAndOffset(offset / blockSize, offset % blockSize);
+			RecyclableMemoryStreamManager.EventsWriter.MemoryStreamOverCapacity(newCapacity,
+				_memoryManager
+					.MaximumStreamCapacity, _tag,
+				AllocationStack);
+			throw new InvalidOperationException("Requested capacity is too large: " + newCapacity + ". Limit is " +
+				_memoryManager.MaximumStreamCapacity);
 		}
 
-		private void EnsureCapacity(int newCapacity)
+		if (_largeBuffer != null)
 		{
-			if (newCapacity > _memoryManager.MaximumStreamCapacity && _memoryManager.MaximumStreamCapacity > 0)
-			{
-				RecyclableMemoryStreamManager.EventsWriter.MemoryStreamOverCapacity(newCapacity,
-					_memoryManager
-						.MaximumStreamCapacity, _tag,
-					AllocationStack);
-				throw new InvalidOperationException("Requested capacity is too large: " + newCapacity + ". Limit is " +
-					_memoryManager.MaximumStreamCapacity);
-			}
-
-			if (_largeBuffer != null)
+			if (newCapacity > _largeBuffer.Length)
 			{
-				if (newCapacity > _largeBuffer.Length)
-				{
-					var newBuffer = _memoryManager.GetLargeBuffer(newCapacity, _tag);
-					InternalRead(newBuffer, 0, _length, 0);
-					ReleaseLargeBuffer();
-					_largeBuffer = newBuffer;
-				}
+				var newBuffer = _memoryManager.GetLargeBuffer(newCapacity, _tag);
+				InternalRead(newBuffer, 0, _length, 0);
+				ReleaseLargeBuffer();
+				_largeBuffer = newBuffer;
 			}
-			else
-				while (Capacity < newCapacity)
-					_blocks.Add(_memoryManager.GetBlock());
 		}
+		else
+			while (Capacity < newCapacity)
+				_blocks.Add(_memoryManager.GetBlock());
+	}
 
-		/// <summary>
-		/// Release the large buffer (either stores it for eventual release or returns it immediately).
-		/// </summary>
-		private void ReleaseLargeBuffer()
+	/// <summary>
+	/// Release the large buffer (either stores it for eventual release or returns it immediately).
+	/// </summary>
+	private void ReleaseLargeBuffer()
+	{
+		if (_memoryManager.AggressiveBufferReturn)
+			_memoryManager.ReturnLargeBuffer(_largeBuffer, _tag);
+		else
 		{
-			if (_memoryManager.AggressiveBufferReturn)
-				_memoryManager.ReturnLargeBuffer(_largeBuffer, _tag);
-			else
-			{
-				if (_dirtyBuffers == null)
-					// We most likely will only ever need space for one
-					_dirtyBuffers = new List<byte[]>(1);
-				_dirtyBuffers.Add(_largeBuffer);
-			}
-
-			_largeBuffer = null;
+			if (_dirtyBuffers == null)
+				// We most likely will only ever need space for one
+				_dirtyBuffers = new List<byte[]>(1);
+			_dirtyBuffers.Add(_largeBuffer);
 		}
 
-		#endregion
+		_largeBuffer = null;
 	}
+
+	#endregion
 }
diff --git a/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamFactory.cs b/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamFactory.cs
index 240f182..0983f7b 100644
--- a/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamFactory.cs
+++ b/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamFactory.cs
@@ -5,43 +5,41 @@
 using System;
 using System.IO;
 
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// A factory for creating memory streams using a recyclable pool of <see cref="MemoryStream" /> instances
-	/// </summary>
-	public sealed class RecyclableMemoryStreamFactory : IMemoryStreamFactory
-	{
-		private const string TagSource = "Elastic.Transport";
-		private readonly RecyclableMemoryStreamManager _manager;
+namespace Elastic.Transport;
 
-		/// <summary> Provide a static instance of this stateless class, so it can be reused</summary>
-		public static RecyclableMemoryStreamFactory Default { get; } = new RecyclableMemoryStreamFactory();
+/// <summary>
+/// A factory for creating memory streams using a recyclable pool of <see cref="MemoryStream" /> instances
+/// </summary>
+public sealed class RecyclableMemoryStreamFactory : MemoryStreamFactory
+{
+	private const string TagSource = "Elastic.Transport";
+	private readonly RecyclableMemoryStreamManager _manager;
 
-		/// <inheritdoc cref="RecyclableMemoryStream"/>
-		public RecyclableMemoryStreamFactory() => _manager = CreateManager(experimental: false);
+	/// <summary> Provide a static instance of this stateless class, so it can be reused</summary>
+	public static RecyclableMemoryStreamFactory Default { get; } = new RecyclableMemoryStreamFactory();
 
-		private static RecyclableMemoryStreamManager CreateManager(bool experimental)
-		{
-			if (!experimental) return new RecyclableMemoryStreamManager() { AggressiveBufferReturn = true };
+	/// <inheritdoc cref="RecyclableMemoryStream"/>
+	public RecyclableMemoryStreamFactory() => _manager = CreateManager(experimental: false);
 
-			const int blockSize = 1024;
-			const int largeBufferMultiple = 1024 * 1024;
-			const int maxBufferSize = 16 * largeBufferMultiple;
-			return new RecyclableMemoryStreamManager(blockSize, largeBufferMultiple, maxBufferSize)
-			{
-				AggressiveBufferReturn = true, MaximumFreeLargePoolBytes = maxBufferSize * 4, MaximumFreeSmallPoolBytes = 100 * blockSize
-			};
+	private static RecyclableMemoryStreamManager CreateManager(bool experimental)
+	{
+		if (!experimental) return new RecyclableMemoryStreamManager() { AggressiveBufferReturn = true };
 
-		}
+		const int blockSize = 1024;
+		const int largeBufferMultiple = 1024 * 1024;
+		const int maxBufferSize = 16 * largeBufferMultiple;
+		return new RecyclableMemoryStreamManager(blockSize, largeBufferMultiple, maxBufferSize)
+		{
+			AggressiveBufferReturn = true, MaximumFreeLargePoolBytes = maxBufferSize * 4, MaximumFreeSmallPoolBytes = 100 * blockSize
+		};
+	}
 
-		/// <inheritdoc />
-		public MemoryStream Create() => _manager.GetStream(Guid.Empty, TagSource);
+	/// <inheritdoc />
+	public override MemoryStream Create() => _manager.GetStream(Guid.Empty, TagSource);
 
-		/// <inheritdoc />
-		public MemoryStream Create(byte[] bytes) => _manager.GetStream(bytes);
+	/// <inheritdoc />
+	public override MemoryStream Create(byte[] bytes) => _manager.GetStream(bytes);
 
-		/// <inheritdoc />
-		public MemoryStream Create(byte[] bytes, int index, int count) => _manager.GetStream(Guid.Empty, TagSource, bytes, index, count);
-	}
+	/// <inheritdoc />
+	public override MemoryStream Create(byte[] bytes, int index, int count) => _manager.GetStream(Guid.Empty, TagSource, bytes, index, count);
 }
diff --git a/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamManager-Events.cs b/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamManager-Events.cs
index 50352ef..00ff313 100644
--- a/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamManager-Events.cs
+++ b/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamManager-Events.cs
@@ -30,130 +30,129 @@
 using System.Diagnostics.Tracing;
 using System.Threading;
 
-namespace Elastic.Transport
-{
+namespace Elastic.Transport;
+
 #if !DOTNETCORE
-	/// <summary>
-	/// Stub for System.Diagnostics.Tracing.EventCounter which is not available on .NET 4.6.1
-	/// </summary>
-	// ReSharper disable once UnusedType.Global
-	internal class EventCounter
-	{
-		// ReSharper disable UnusedParameter.Local
-		public EventCounter(string blocks, RecyclableMemoryStreamManager.Events eventsWriter) { }
-		// ReSharper restore UnusedParameter.Local
+/// <summary>
+/// Stub for System.Diagnostics.Tracing.EventCounter which is not available on .NET 4.6.1
+/// </summary>
+// ReSharper disable once UnusedType.Global
+internal sealed class EventCounter
+{
+	// ReSharper disable UnusedParameter.Local
+	public EventCounter(string blocks, RecyclableMemoryStreamManager.Events eventsWriter) { }
+	// ReSharper restore UnusedParameter.Local
 
-		public void WriteMetric(long v) { }
-	}
+	public void WriteMetric(long v) { }
+}
 #endif
 #if NETSTANDARD2_0 || NETFRAMEWORK
-	internal class PollingCounter : IDisposable
-	{
-		// ReSharper disable UnusedParameter.Local
-		public PollingCounter(string largeBuffers, RecyclableMemoryStreamManager.Events eventsWriter, Func<double> func) { }
-		// ReSharper restore UnusedParameter.Local
+internal sealed class PollingCounter : IDisposable
+{
+	// ReSharper disable UnusedParameter.Local
+	public PollingCounter(string largeBuffers, RecyclableMemoryStreamManager.Events eventsWriter, Func<double> func) { }
+	// ReSharper restore UnusedParameter.Local
 
-		public void Dispose() {}
-	}
+	public void Dispose() {}
+}
 #endif
 
-	internal sealed partial class RecyclableMemoryStreamManager
+internal sealed partial class RecyclableMemoryStreamManager
+{
+	public static readonly Events EventsWriter = new Events();
+	
+	[EventSource(Name = "Elastic-Transport-RecyclableMemoryStream", Guid = "{AD44FDAC-D3FC-460A-9EBE-E55A3569A8F6}")]
+	public sealed class Events : EventSource
 	{
-		public static readonly Events EventsWriter = new Events();
-		
-		[EventSource(Name = "Elastic-Transport-RecyclableMemoryStream", Guid = "{AD44FDAC-D3FC-460A-9EBE-E55A3569A8F6}")]
-		public sealed class Events : EventSource
+
+		public enum MemoryStreamBufferType
 		{
+			Small,
+			Large
+		}
+
+		public enum MemoryStreamDiscardReason
+		{
+			TooLarge,
+			EnoughFree
+		}
+
+		[Event(1, Level = EventLevel.Verbose)]
+		public void MemoryStreamCreated(Guid guid, string tag, int requestedSize)
+		{
+			if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
+				WriteEvent(1, guid, tag ?? string.Empty, requestedSize);
+		}
+
+		[Event(2, Level = EventLevel.Verbose)]
+		public void MemoryStreamDisposed(Guid guid, string tag)
+		{
+			if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
+				WriteEvent(2, guid, tag ?? string.Empty);
+		}
 
-			public enum MemoryStreamBufferType
-			{
-				Small,
-				Large
-			}
-
-			public enum MemoryStreamDiscardReason
-			{
-				TooLarge,
-				EnoughFree
-			}
-
-			[Event(1, Level = EventLevel.Verbose)]
-			public void MemoryStreamCreated(Guid guid, string tag, int requestedSize)
-			{
-				if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
-					WriteEvent(1, guid, tag ?? string.Empty, requestedSize);
-			}
-
-			[Event(2, Level = EventLevel.Verbose)]
-			public void MemoryStreamDisposed(Guid guid, string tag)
-			{
-				if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
-					WriteEvent(2, guid, tag ?? string.Empty);
-			}
-
-			[Event(3, Level = EventLevel.Critical)]
-			public void MemoryStreamDoubleDispose(Guid guid, string tag, string allocationStack, string disposeStack1, string disposeStack2)
-			{
-				if (IsEnabled())
-					WriteEvent(3, guid, tag ?? string.Empty, allocationStack ?? string.Empty,
-						disposeStack1 ?? string.Empty, disposeStack2 ?? string.Empty);
-			}
-
-			[Event(4, Level = EventLevel.Error)]
-			public void MemoryStreamFinalized(Guid guid, string tag, string allocationStack)
-			{
-				if (IsEnabled())
-					WriteEvent(4, guid, tag ?? string.Empty, allocationStack ?? string.Empty);
-			}
-
-			[Event(5, Level = EventLevel.Verbose)]
-			public void MemoryStreamToArray(Guid guid, string tag, string stack, int size)
-			{
-				if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
-					WriteEvent(5, guid, tag ?? string.Empty, stack ?? string.Empty, size);
-			}
-
-			[Event(6, Level = EventLevel.Informational)]
-			public void MemoryStreamManagerInitialized(int blockSize, int largeBufferMultiple, int maximumBufferSize)
-			{
-				if (IsEnabled())
-					WriteEvent(6, blockSize, largeBufferMultiple, maximumBufferSize);
-			}
-
-			[Event(7, Level = EventLevel.Verbose)]
-			public void MemoryStreamNewBlockCreated(long smallPoolInUseBytes)
-			{
-				if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
-					WriteEvent(7, smallPoolInUseBytes);
-			}
-
-			[Event(8, Level = EventLevel.Verbose)]
-			public void MemoryStreamNewLargeBufferCreated(int requiredSize, long largePoolInUseBytes)
-			{
-				if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
-					WriteEvent(8, requiredSize, largePoolInUseBytes);
-			}
-
-			[Event(9, Level = EventLevel.Verbose)]
-			public void MemoryStreamNonPooledLargeBufferCreated(int requiredSize, string tag, string allocationStack)
-			{
-				if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
-					WriteEvent(9, requiredSize, tag ?? string.Empty, allocationStack ?? string.Empty);
-			}
-
-			[Event(10, Level = EventLevel.Warning)]
-			public void MemoryStreamDiscardBuffer(MemoryStreamBufferType bufferType, string tag, MemoryStreamDiscardReason reason)
-			{
-				if (IsEnabled())
-					WriteEvent(10, bufferType, tag ?? string.Empty, reason);
-			}
-
-			[Event(11, Level = EventLevel.Error)]
-			public void MemoryStreamOverCapacity(int requestedCapacity, long maxCapacity, string tag, string allocationStack)
-			{
-				if (IsEnabled())
-					WriteEvent(11, requestedCapacity, maxCapacity, tag ?? string.Empty, allocationStack ?? string.Empty);
-			}
+		[Event(3, Level = EventLevel.Critical)]
+		public void MemoryStreamDoubleDispose(Guid guid, string tag, string allocationStack, string disposeStack1, string disposeStack2)
+		{
+			if (IsEnabled())
+				WriteEvent(3, guid, tag ?? string.Empty, allocationStack ?? string.Empty,
+					disposeStack1 ?? string.Empty, disposeStack2 ?? string.Empty);
+		}
+
+		[Event(4, Level = EventLevel.Error)]
+		public void MemoryStreamFinalized(Guid guid, string tag, string allocationStack)
+		{
+			if (IsEnabled())
+				WriteEvent(4, guid, tag ?? string.Empty, allocationStack ?? string.Empty);
+		}
+
+		[Event(5, Level = EventLevel.Verbose)]
+		public void MemoryStreamToArray(Guid guid, string tag, string stack, int size)
+		{
+			if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
+				WriteEvent(5, guid, tag ?? string.Empty, stack ?? string.Empty, size);
+		}
+
+		[Event(6, Level = EventLevel.Informational)]
+		public void MemoryStreamManagerInitialized(int blockSize, int largeBufferMultiple, int maximumBufferSize)
+		{
+			if (IsEnabled())
+				WriteEvent(6, blockSize, largeBufferMultiple, maximumBufferSize);
+		}
+
+		[Event(7, Level = EventLevel.Verbose)]
+		public void MemoryStreamNewBlockCreated(long smallPoolInUseBytes)
+		{
+			if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
+				WriteEvent(7, smallPoolInUseBytes);
+		}
+
+		[Event(8, Level = EventLevel.Verbose)]
+		public void MemoryStreamNewLargeBufferCreated(int requiredSize, long largePoolInUseBytes)
+		{
+			if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
+				WriteEvent(8, requiredSize, largePoolInUseBytes);
+		}
+
+		[Event(9, Level = EventLevel.Verbose)]
+		public void MemoryStreamNonPooledLargeBufferCreated(int requiredSize, string tag, string allocationStack)
+		{
+			if (IsEnabled(EventLevel.Verbose, EventKeywords.None))
+				WriteEvent(9, requiredSize, tag ?? string.Empty, allocationStack ?? string.Empty);
+		}
+
+		[Event(10, Level = EventLevel.Warning)]
+		public void MemoryStreamDiscardBuffer(MemoryStreamBufferType bufferType, string tag, MemoryStreamDiscardReason reason)
+		{
+			if (IsEnabled())
+				WriteEvent(10, bufferType, tag ?? string.Empty, reason);
+		}
+
+		[Event(11, Level = EventLevel.Error)]
+		public void MemoryStreamOverCapacity(int requestedCapacity, long maxCapacity, string tag, string allocationStack)
+		{
+			if (IsEnabled())
+				WriteEvent(11, requestedCapacity, maxCapacity, tag ?? string.Empty, allocationStack ?? string.Empty);
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamManager.cs b/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamManager.cs
index 32fe11b..51eb515 100644
--- a/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamManager.cs
+++ b/src/Elastic.Transport/Components/Providers/RecyclableMemoryStreamManager.cs
@@ -30,663 +30,662 @@
 using System.IO;
 using System.Threading;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Manages pools of RecyclableMemoryStream objects.
+/// </summary>
+/// <remarks>
+/// There are two pools managed in here. The small pool contains same-sized buffers that are handed to streams
+/// as they write more data.
+/// For scenarios that need to call GetBuffer(), the large pool contains buffers of various sizes, all
+/// multiples/exponentials of LargeBufferMultiple (1 MB by default). They are split by size to avoid overly-wasteful buffer
+/// usage. There should be far fewer 8 MB buffers than 1 MB buffers, for example.
+/// </remarks>
+internal sealed partial class RecyclableMemoryStreamManager
 {
 	/// <summary>
-	/// Manages pools of RecyclableMemoryStream objects.
+	/// Generic delegate for handling events without any arguments.
 	/// </summary>
-	/// <remarks>
-	/// There are two pools managed in here. The small pool contains same-sized buffers that are handed to streams
-	/// as they write more data.
-	/// For scenarios that need to call GetBuffer(), the large pool contains buffers of various sizes, all
-	/// multiples/exponentials of LargeBufferMultiple (1 MB by default). They are split by size to avoid overly-wasteful buffer
-	/// usage. There should be far fewer 8 MB buffers than 1 MB buffers, for example.
-	/// </remarks>
-	internal partial class RecyclableMemoryStreamManager
+	public delegate void EventHandler();
+
+	/// <summary>
+	/// Delegate for handling large buffer discard reports.
+	/// </summary>
+	/// <param name="reason">Reason the buffer was discarded.</param>
+	public delegate void LargeBufferDiscardedEventHandler(Events.MemoryStreamDiscardReason reason);
+
+	/// <summary>
+	/// Delegate for handling reports of stream size when streams are allocated
+	/// </summary>
+	/// <param name="bytes">Bytes allocated.</param>
+	public delegate void StreamLengthReportHandler(long bytes);
+
+	/// <summary>
+	/// Delegate for handling periodic reporting of memory use statistics.
+	/// </summary>
+	/// <param name="smallPoolInUseBytes">Bytes currently in use in the small pool.</param>
+	/// <param name="smallPoolFreeBytes">Bytes currently free in the small pool.</param>
+	/// <param name="largePoolInUseBytes">Bytes currently in use in the large pool.</param>
+	/// <param name="largePoolFreeBytes">Bytes currently free in the large pool.</param>
+	public delegate void UsageReportEventHandler(
+		long smallPoolInUseBytes, long smallPoolFreeBytes, long largePoolInUseBytes, long largePoolFreeBytes
+	);
+
+	public const int DefaultBlockSize = 128 * 1024;
+	public const int DefaultLargeBufferMultiple = 1024 * 1024;
+	public const int DefaultMaximumBufferSize = 128 * 1024 * 1024;
+
+	private readonly long[] _largeBufferFreeSize;
+	private readonly long[] _largeBufferInUseSize;
+
+
+	/// <summary>
+	/// pools[0] = 1x largeBufferMultiple buffers
+	/// pools[1] = 2x largeBufferMultiple buffers
+	/// pools[2] = 3x(multiple)/4x(exponential) largeBufferMultiple buffers
+	/// etc., up to maximumBufferSize
+	/// </summary>
+	private readonly ConcurrentStack<byte[]>[] _largePools;
+
+	private readonly ConcurrentStack<byte[]> _smallPool;
+
+	private long _smallPoolFreeSize;
+	private long _smallPoolInUseSize;
+
+	/// <summary>
+	/// Initializes the memory manager with the default block/buffer specifications.
+	/// </summary>
+	public RecyclableMemoryStreamManager()
+		: this(DefaultBlockSize, DefaultLargeBufferMultiple, DefaultMaximumBufferSize, false) { }
+
+	/// <summary>
+	/// Initializes the memory manager with the given block requiredSize.
+	/// </summary>
+	/// <param name="blockSize">Size of each block that is pooled. Must be > 0.</param>
+	/// <param name="largeBufferMultiple">Each large buffer will be a multiple of this value.</param>
+	/// <param name="maximumBufferSize">Buffers larger than this are not pooled</param>
+	/// <exception cref="ArgumentOutOfRangeException">
+	/// blockSize is not a positive number, or largeBufferMultiple is not a
+	/// positive number, or maximumBufferSize is less than blockSize.
+	/// </exception>
+	/// <exception cref="ArgumentException">maximumBufferSize is not a multiple of largeBufferMultiple</exception>
+	public RecyclableMemoryStreamManager(int blockSize, int largeBufferMultiple, int maximumBufferSize)
+		: this(blockSize, largeBufferMultiple, maximumBufferSize, false) { }
+
+	/// <summary>
+	/// Initializes the memory manager with the given block requiredSize.
+	/// </summary>
+	/// <param name="blockSize">Size of each block that is pooled. Must be > 0.</param>
+	/// <param name="largeBufferMultiple">Each large buffer will be a multiple/exponential of this value.</param>
+	/// <param name="maximumBufferSize">Buffers larger than this are not pooled</param>
+	/// <param name="useExponentialLargeBuffer">Switch to exponential large buffer allocation strategy</param>
+	/// <exception cref="ArgumentOutOfRangeException">
+	/// blockSize is not a positive number, or largeBufferMultiple is not a
+	/// positive number, or maximumBufferSize is less than blockSize.
+	/// </exception>
+	/// <exception cref="ArgumentException">maximumBufferSize is not a multiple/exponential of largeBufferMultiple</exception>
+	public RecyclableMemoryStreamManager(int blockSize, int largeBufferMultiple, int maximumBufferSize, bool useExponentialLargeBuffer)
 	{
-		/// <summary>
-		/// Generic delegate for handling events without any arguments.
-		/// </summary>
-		public delegate void EventHandler();
-
-		/// <summary>
-		/// Delegate for handling large buffer discard reports.
-		/// </summary>
-		/// <param name="reason">Reason the buffer was discarded.</param>
-		public delegate void LargeBufferDiscardedEventHandler(Events.MemoryStreamDiscardReason reason);
-
-		/// <summary>
-		/// Delegate for handling reports of stream size when streams are allocated
-		/// </summary>
-		/// <param name="bytes">Bytes allocated.</param>
-		public delegate void StreamLengthReportHandler(long bytes);
-
-		/// <summary>
-		/// Delegate for handling periodic reporting of memory use statistics.
-		/// </summary>
-		/// <param name="smallPoolInUseBytes">Bytes currently in use in the small pool.</param>
-		/// <param name="smallPoolFreeBytes">Bytes currently free in the small pool.</param>
-		/// <param name="largePoolInUseBytes">Bytes currently in use in the large pool.</param>
-		/// <param name="largePoolFreeBytes">Bytes currently free in the large pool.</param>
-		public delegate void UsageReportEventHandler(
-			long smallPoolInUseBytes, long smallPoolFreeBytes, long largePoolInUseBytes, long largePoolFreeBytes
-		);
-
-		public const int DefaultBlockSize = 128 * 1024;
-		public const int DefaultLargeBufferMultiple = 1024 * 1024;
-		public const int DefaultMaximumBufferSize = 128 * 1024 * 1024;
-
-		private readonly long[] _largeBufferFreeSize;
-		private readonly long[] _largeBufferInUseSize;
-
-
-		/// <summary>
-		/// pools[0] = 1x largeBufferMultiple buffers
-		/// pools[1] = 2x largeBufferMultiple buffers
-		/// pools[2] = 3x(multiple)/4x(exponential) largeBufferMultiple buffers
-		/// etc., up to maximumBufferSize
-		/// </summary>
-		private readonly ConcurrentStack<byte[]>[] _largePools;
-
-		private readonly ConcurrentStack<byte[]> _smallPool;
-
-		private long _smallPoolFreeSize;
-		private long _smallPoolInUseSize;
-
-		/// <summary>
-		/// Initializes the memory manager with the default block/buffer specifications.
-		/// </summary>
-		public RecyclableMemoryStreamManager()
-			: this(DefaultBlockSize, DefaultLargeBufferMultiple, DefaultMaximumBufferSize, false) { }
-
-		/// <summary>
-		/// Initializes the memory manager with the given block requiredSize.
-		/// </summary>
-		/// <param name="blockSize">Size of each block that is pooled. Must be > 0.</param>
-		/// <param name="largeBufferMultiple">Each large buffer will be a multiple of this value.</param>
-		/// <param name="maximumBufferSize">Buffers larger than this are not pooled</param>
-		/// <exception cref="ArgumentOutOfRangeException">
-		/// blockSize is not a positive number, or largeBufferMultiple is not a
-		/// positive number, or maximumBufferSize is less than blockSize.
-		/// </exception>
-		/// <exception cref="ArgumentException">maximumBufferSize is not a multiple of largeBufferMultiple</exception>
-		public RecyclableMemoryStreamManager(int blockSize, int largeBufferMultiple, int maximumBufferSize)
-			: this(blockSize, largeBufferMultiple, maximumBufferSize, false) { }
-
-		/// <summary>
-		/// Initializes the memory manager with the given block requiredSize.
-		/// </summary>
-		/// <param name="blockSize">Size of each block that is pooled. Must be > 0.</param>
-		/// <param name="largeBufferMultiple">Each large buffer will be a multiple/exponential of this value.</param>
-		/// <param name="maximumBufferSize">Buffers larger than this are not pooled</param>
-		/// <param name="useExponentialLargeBuffer">Switch to exponential large buffer allocation strategy</param>
-		/// <exception cref="ArgumentOutOfRangeException">
-		/// blockSize is not a positive number, or largeBufferMultiple is not a
-		/// positive number, or maximumBufferSize is less than blockSize.
-		/// </exception>
-		/// <exception cref="ArgumentException">maximumBufferSize is not a multiple/exponential of largeBufferMultiple</exception>
-		public RecyclableMemoryStreamManager(int blockSize, int largeBufferMultiple, int maximumBufferSize, bool useExponentialLargeBuffer)
-		{
-			if (blockSize <= 0) throw new ArgumentOutOfRangeException(nameof(blockSize), blockSize, "blockSize must be a positive number");
+		if (blockSize <= 0) throw new ArgumentOutOfRangeException(nameof(blockSize), blockSize, "blockSize must be a positive number");
 
-			if (largeBufferMultiple <= 0)
-				throw new ArgumentOutOfRangeException(nameof(largeBufferMultiple),
-					"largeBufferMultiple must be a positive number");
+		if (largeBufferMultiple <= 0)
+			throw new ArgumentOutOfRangeException(nameof(largeBufferMultiple),
+				"largeBufferMultiple must be a positive number");
 
-			if (maximumBufferSize < blockSize)
-				throw new ArgumentOutOfRangeException(nameof(maximumBufferSize),
-					"maximumBufferSize must be at least blockSize");
+		if (maximumBufferSize < blockSize)
+			throw new ArgumentOutOfRangeException(nameof(maximumBufferSize),
+				"maximumBufferSize must be at least blockSize");
 
-			BlockSize = blockSize;
-			LargeBufferMultiple = largeBufferMultiple;
-			MaximumBufferSize = maximumBufferSize;
-			UseExponentialLargeBuffer = useExponentialLargeBuffer;
+		BlockSize = blockSize;
+		LargeBufferMultiple = largeBufferMultiple;
+		MaximumBufferSize = maximumBufferSize;
+		UseExponentialLargeBuffer = useExponentialLargeBuffer;
 
-			if (!IsLargeBufferSize(maximumBufferSize))
-				throw new ArgumentException(string.Format("maximumBufferSize is not {0} of largeBufferMultiple",
-						UseExponentialLargeBuffer ? "an exponential" : "a multiple"),
-					nameof(maximumBufferSize));
+		if (!IsLargeBufferSize(maximumBufferSize))
+			throw new ArgumentException(string.Format("maximumBufferSize is not {0} of largeBufferMultiple",
+					UseExponentialLargeBuffer ? "an exponential" : "a multiple"),
+				nameof(maximumBufferSize));
 
-			_smallPool = new ConcurrentStack<byte[]>();
-			var numLargePools = useExponentialLargeBuffer
-				// ReSharper disable once PossibleLossOfFraction
-				// Not our code assume loss is intentional
-				? (int)Math.Log(maximumBufferSize / largeBufferMultiple, 2) + 1
-				: maximumBufferSize / largeBufferMultiple;
+		_smallPool = new ConcurrentStack<byte[]>();
+		var numLargePools = useExponentialLargeBuffer
+			// ReSharper disable once PossibleLossOfFraction
+			// Not our code assume loss is intentional
+			? (int)Math.Log(maximumBufferSize / largeBufferMultiple, 2) + 1
+			: maximumBufferSize / largeBufferMultiple;
 
-			// +1 to store size of bytes in use that are too large to be pooled
-			_largeBufferInUseSize = new long[numLargePools + 1];
-			_largeBufferFreeSize = new long[numLargePools];
+		// +1 to store size of bytes in use that are too large to be pooled
+		_largeBufferInUseSize = new long[numLargePools + 1];
+		_largeBufferFreeSize = new long[numLargePools];
 
-			_largePools = new ConcurrentStack<byte[]>[numLargePools];
+		_largePools = new ConcurrentStack<byte[]>[numLargePools];
 
-			for (var i = 0; i < _largePools.Length; ++i) _largePools[i] = new ConcurrentStack<byte[]>();
+		for (var i = 0; i < _largePools.Length; ++i) _largePools[i] = new ConcurrentStack<byte[]>();
 
-			EventsWriter.MemoryStreamManagerInitialized(blockSize, largeBufferMultiple, maximumBufferSize);
-		}
+		EventsWriter.MemoryStreamManagerInitialized(blockSize, largeBufferMultiple, maximumBufferSize);
+	}
+
+	/// <summary>
+	/// Whether dirty buffers can be immediately returned to the buffer pool. E.g. when GetBuffer() is called on
+	/// a stream and creates a single large buffer, if this setting is enabled, the other blocks will be returned
+	/// to the buffer pool immediately.
+	/// Note when enabling this setting that the user is responsible for ensuring that any buffer previously
+	/// retrieved from a stream which is subsequently modified is not used after modification (as it may no longer
+	/// be valid).
+	/// </summary>
+	public bool AggressiveBufferReturn { get; set; }
+
+	/// <summary>
+	/// The size of each block. It must be set at creation and cannot be changed.
+	/// </summary>
+	public int BlockSize { get; }
+
+	/// <summary>
+	/// Whether to save callstacks for stream allocations. This can help in debugging.
+	/// It should NEVER be turned on generally in production.
+	/// </summary>
+	public bool GenerateCallStacks { get; set; }
+
+	/// <summary>
+	/// All buffers are multiples/exponentials of this number. It must be set at creation and cannot be changed.
+	/// </summary>
+	public int LargeBufferMultiple { get; }
 
-		/// <summary>
-		/// Whether dirty buffers can be immediately returned to the buffer pool. E.g. when GetBuffer() is called on
-		/// a stream and creates a single large buffer, if this setting is enabled, the other blocks will be returned
-		/// to the buffer pool immediately.
-		/// Note when enabling this setting that the user is responsible for ensuring that any buffer previously
-		/// retrieved from a stream which is subsequently modified is not used after modification (as it may no longer
-		/// be valid).
-		/// </summary>
-		public bool AggressiveBufferReturn { get; set; }
-
-		/// <summary>
-		/// The size of each block. It must be set at creation and cannot be changed.
-		/// </summary>
-		public int BlockSize { get; }
-
-		/// <summary>
-		/// Whether to save callstacks for stream allocations. This can help in debugging.
-		/// It should NEVER be turned on generally in production.
-		/// </summary>
-		public bool GenerateCallStacks { get; set; }
-
-		/// <summary>
-		/// All buffers are multiples/exponentials of this number. It must be set at creation and cannot be changed.
-		/// </summary>
-		public int LargeBufferMultiple { get; }
-
-		/// <summary>
-		/// How many buffers are in the large pool
-		/// </summary>
-		public long LargeBuffersFree
+	/// <summary>
+	/// How many buffers are in the large pool
+	/// </summary>
+	public long LargeBuffersFree
+	{
+		get
 		{
-			get
-			{
-				long free = 0;
-				foreach (var pool in _largePools) free += pool.Count;
-				return free;
-			}
+			long free = 0;
+			foreach (var pool in _largePools) free += pool.Count;
+			return free;
 		}
+	}
 
-		/// <summary>
-		/// Number of bytes in large pool not currently in use
-		/// </summary>
-		public long LargePoolFreeSize
+	/// <summary>
+	/// Number of bytes in large pool not currently in use
+	/// </summary>
+	public long LargePoolFreeSize
+	{
+		get
 		{
-			get
-			{
-				long sum = 0;
-				foreach (var freeSize in _largeBufferFreeSize) sum += freeSize;
+			long sum = 0;
+			foreach (var freeSize in _largeBufferFreeSize) sum += freeSize;
 
-				return sum;
-			}
+			return sum;
 		}
+	}
 
-		/// <summary>
-		/// Number of bytes currently in use by streams from the large pool
-		/// </summary>
-		public long LargePoolInUseSize
+	/// <summary>
+	/// Number of bytes currently in use by streams from the large pool
+	/// </summary>
+	public long LargePoolInUseSize
+	{
+		get
 		{
-			get
-			{
-				long sum = 0;
-				foreach (var inUseSize in _largeBufferInUseSize) sum += inUseSize;
+			long sum = 0;
+			foreach (var inUseSize in _largeBufferInUseSize) sum += inUseSize;
 
-				return sum;
-			}
+			return sum;
 		}
+	}
 
-		/// <summary>
-		/// Gets the maximum buffer size.
-		/// </summary>
-		/// <remarks>
-		/// Any buffer that is returned to the pool that is larger than this will be
-		/// discarded and garbage collected.
-		/// </remarks>
-		public int MaximumBufferSize { get; }
-
-		/// <summary>
-		/// How many bytes of large free buffers to allow before we start dropping
-		/// those returned to us.
-		/// </summary>
-		public long MaximumFreeLargePoolBytes { get; set; }
-
-		/// <summary>
-		/// How many bytes of small free blocks to allow before we start dropping
-		/// those returned to us.
-		/// </summary>
-		public long MaximumFreeSmallPoolBytes { get; set; }
-
-		/// <summary>
-		/// Maximum stream capacity in bytes. Attempts to set a larger capacity will
-		/// result in an exception.
-		/// </summary>
-		/// <remarks>A value of 0 indicates no limit.</remarks>
-		public long MaximumStreamCapacity { get; set; }
-
-		/// <summary>
-		/// How many blocks are in the small pool
-		/// </summary>
-		public long SmallBlocksFree => _smallPool.Count;
-
-		/// <summary>
-		/// Number of bytes in small pool not currently in use
-		/// </summary>
-		public long SmallPoolFreeSize => _smallPoolFreeSize;
-
-		/// <summary>
-		/// Number of bytes currently in use by stream from the small pool
-		/// </summary>
-		public long SmallPoolInUseSize => _smallPoolInUseSize;
-
-		/// <summary>
-		/// Use exponential large buffer allocation strategy. It must be set at creation and cannot be changed.
-		/// </summary>
-		public bool UseExponentialLargeBuffer { get; }
-
-		/// <summary>
-		/// Use multiple large buffer allocation strategy. It must be set at creation and cannot be changed.
-		/// </summary>
-		public bool UseMultipleLargeBuffer => !UseExponentialLargeBuffer;
-
-		/// <summary>
-		/// Removes and returns a single block from the pool.
-		/// </summary>
-		/// <returns>A byte[] array</returns>
-		internal byte[] GetBlock()
-		{
-			if (!_smallPool.TryPop(out var block))
-			{
-				// We'll add this back to the pool when the stream is disposed
-				// (unless our free pool is too large)
-				block = new byte[BlockSize];
-				EventsWriter.MemoryStreamNewBlockCreated(_smallPoolInUseSize);
-				ReportBlockCreated();
-			}
-			else
-				Interlocked.Add(ref _smallPoolFreeSize, -BlockSize);
+	/// <summary>
+	/// Gets the maximum buffer size.
+	/// </summary>
+	/// <remarks>
+	/// Any buffer that is returned to the pool that is larger than this will be
+	/// discarded and garbage collected.
+	/// </remarks>
+	public int MaximumBufferSize { get; }
 
-			Interlocked.Add(ref _smallPoolInUseSize, BlockSize);
-			return block;
-		}
+	/// <summary>
+	/// How many bytes of large free buffers to allow before we start dropping
+	/// those returned to us.
+	/// </summary>
+	public long MaximumFreeLargePoolBytes { get; set; }
 
-		/// <summary>
-		/// Returns a buffer of arbitrary size from the large buffer pool. This buffer
-		/// will be at least the requiredSize and always be a multiple/exponential of largeBufferMultiple.
-		/// </summary>
-		/// <param name="requiredSize">The minimum length of the buffer</param>
-		/// <param name="tag">The tag of the stream returning this buffer, for logging if necessary.</param>
-		/// <returns>A buffer of at least the required size.</returns>
-		internal byte[] GetLargeBuffer(int requiredSize, string tag)
-		{
-			requiredSize = RoundToLargeBufferSize(requiredSize);
+	/// <summary>
+	/// How many bytes of small free blocks to allow before we start dropping
+	/// those returned to us.
+	/// </summary>
+	public long MaximumFreeSmallPoolBytes { get; set; }
 
-			var poolIndex = GetPoolIndex(requiredSize);
+	/// <summary>
+	/// Maximum stream capacity in bytes. Attempts to set a larger capacity will
+	/// result in an exception.
+	/// </summary>
+	/// <remarks>A value of 0 indicates no limit.</remarks>
+	public long MaximumStreamCapacity { get; set; }
 
-			byte[] buffer;
-			if (poolIndex < _largePools.Length)
-			{
-				if (!_largePools[poolIndex].TryPop(out buffer))
-				{
-					buffer = new byte[requiredSize];
-
-					EventsWriter.MemoryStreamNewLargeBufferCreated(requiredSize, LargePoolInUseSize);
-					ReportLargeBufferCreated();
-				}
-				else
-					Interlocked.Add(ref _largeBufferFreeSize[poolIndex], -buffer.Length);
-			}
-			else
-			{
-				// Buffer is too large to pool. They get a new buffer.
+	/// <summary>
+	/// How many blocks are in the small pool
+	/// </summary>
+	public long SmallBlocksFree => _smallPool.Count;
 
-				// We still want to track the size, though, and we've reserved a slot
-				// in the end of the inuse array for nonpooled bytes in use.
-				poolIndex = _largeBufferInUseSize.Length - 1;
+	/// <summary>
+	/// Number of bytes in small pool not currently in use
+	/// </summary>
+	public long SmallPoolFreeSize => _smallPoolFreeSize;
 
-				// We still want to round up to reduce heap fragmentation.
-				buffer = new byte[requiredSize];
-				string callStack = null;
-				if (GenerateCallStacks)
-					// Grab the stack -- we want to know who requires such large buffers
-					callStack = Environment.StackTrace;
-				EventsWriter.MemoryStreamNonPooledLargeBufferCreated(requiredSize, tag, callStack);
-				ReportLargeBufferCreated();
-			}
+	/// <summary>
+	/// Number of bytes currently in use by stream from the small pool
+	/// </summary>
+	public long SmallPoolInUseSize => _smallPoolInUseSize;
+
+	/// <summary>
+	/// Use exponential large buffer allocation strategy. It must be set at creation and cannot be changed.
+	/// </summary>
+	public bool UseExponentialLargeBuffer { get; }
 
-			Interlocked.Add(ref _largeBufferInUseSize[poolIndex], buffer.Length);
+	/// <summary>
+	/// Use multiple large buffer allocation strategy. It must be set at creation and cannot be changed.
+	/// </summary>
+	public bool UseMultipleLargeBuffer => !UseExponentialLargeBuffer;
 
-			return buffer;
+	/// <summary>
+	/// Removes and returns a single block from the pool.
+	/// </summary>
+	/// <returns>A byte[] array</returns>
+	internal byte[] GetBlock()
+	{
+		if (!_smallPool.TryPop(out var block))
+		{
+			// We'll add this back to the pool when the stream is disposed
+			// (unless our free pool is too large)
+			block = new byte[BlockSize];
+			EventsWriter.MemoryStreamNewBlockCreated(_smallPoolInUseSize);
+			ReportBlockCreated();
 		}
+		else
+			Interlocked.Add(ref _smallPoolFreeSize, -BlockSize);
+
+		Interlocked.Add(ref _smallPoolInUseSize, BlockSize);
+		return block;
+	}
 
-		private int RoundToLargeBufferSize(int requiredSize)
+	/// <summary>
+	/// Returns a buffer of arbitrary size from the large buffer pool. This buffer
+	/// will be at least the requiredSize and always be a multiple/exponential of largeBufferMultiple.
+	/// </summary>
+	/// <param name="requiredSize">The minimum length of the buffer</param>
+	/// <param name="tag">The tag of the stream returning this buffer, for logging if necessary.</param>
+	/// <returns>A buffer of at least the required size.</returns>
+	internal byte[] GetLargeBuffer(int requiredSize, string tag)
+	{
+		requiredSize = RoundToLargeBufferSize(requiredSize);
+
+		var poolIndex = GetPoolIndex(requiredSize);
+
+		byte[] buffer;
+		if (poolIndex < _largePools.Length)
 		{
-			if (UseExponentialLargeBuffer)
+			if (!_largePools[poolIndex].TryPop(out buffer))
 			{
-				var pow = 1;
-				while (LargeBufferMultiple * pow < requiredSize) pow <<= 1;
-				return LargeBufferMultiple * pow;
+				buffer = new byte[requiredSize];
+
+				EventsWriter.MemoryStreamNewLargeBufferCreated(requiredSize, LargePoolInUseSize);
+				ReportLargeBufferCreated();
 			}
 			else
-				return (requiredSize + LargeBufferMultiple - 1) / LargeBufferMultiple * LargeBufferMultiple;
+				Interlocked.Add(ref _largeBufferFreeSize[poolIndex], -buffer.Length);
+		}
+		else
+		{
+			// Buffer is too large to pool. They get a new buffer.
+
+			// We still want to track the size, though, and we've reserved a slot
+			// in the end of the inuse array for nonpooled bytes in use.
+			poolIndex = _largeBufferInUseSize.Length - 1;
+
+			// We still want to round up to reduce heap fragmentation.
+			buffer = new byte[requiredSize];
+			string callStack = null;
+			if (GenerateCallStacks)
+				// Grab the stack -- we want to know who requires such large buffers
+				callStack = Environment.StackTrace;
+			EventsWriter.MemoryStreamNonPooledLargeBufferCreated(requiredSize, tag, callStack);
+			ReportLargeBufferCreated();
 		}
 
-		private bool IsLargeBufferSize(int value) =>
-			value != 0 && (UseExponentialLargeBuffer
-				? value == RoundToLargeBufferSize(value)
-				: value % LargeBufferMultiple == 0);
+		Interlocked.Add(ref _largeBufferInUseSize[poolIndex], buffer.Length);
 
-		private int GetPoolIndex(int length)
+		return buffer;
+	}
+
+	private int RoundToLargeBufferSize(int requiredSize)
+	{
+		if (UseExponentialLargeBuffer)
 		{
-			if (UseExponentialLargeBuffer)
-			{
-				var index = 0;
-				while (LargeBufferMultiple << index < length) ++index;
-				return index;
-			}
-			else
-				return length / LargeBufferMultiple - 1;
+			var pow = 1;
+			while (LargeBufferMultiple * pow < requiredSize) pow <<= 1;
+			return LargeBufferMultiple * pow;
 		}
+		else
+			return (requiredSize + LargeBufferMultiple - 1) / LargeBufferMultiple * LargeBufferMultiple;
+	}
 
-		/// <summary>
-		/// Returns the buffer to the large pool
-		/// </summary>
-		/// <param name="buffer">The buffer to return.</param>
-		/// <param name="tag">The tag of the stream returning this buffer, for logging if necessary.</param>
-		/// <exception cref="ArgumentNullException">buffer is null</exception>
-		/// <exception cref="ArgumentException">
-		/// buffer.Length is not a multiple/exponential of LargeBufferMultiple (it did not
-		/// originate from this pool)
-		/// </exception>
-		internal void ReturnLargeBuffer(byte[] buffer, string tag)
+	private bool IsLargeBufferSize(int value) =>
+		value != 0 && (UseExponentialLargeBuffer
+			? value == RoundToLargeBufferSize(value)
+			: value % LargeBufferMultiple == 0);
+
+	private int GetPoolIndex(int length)
+	{
+		if (UseExponentialLargeBuffer)
 		{
-			if (buffer == null) throw new ArgumentNullException(nameof(buffer));
+			var index = 0;
+			while (LargeBufferMultiple << index < length) ++index;
+			return index;
+		}
+		else
+			return length / LargeBufferMultiple - 1;
+	}
 
-			if (!IsLargeBufferSize(buffer.Length))
-				throw new ArgumentException(
-					string.Format("buffer did not originate from this memory manager. The size is not {0} of ",
-						UseExponentialLargeBuffer ? "an exponential" : "a multiple") +
-					LargeBufferMultiple);
+	/// <summary>
+	/// Returns the buffer to the large pool
+	/// </summary>
+	/// <param name="buffer">The buffer to return.</param>
+	/// <param name="tag">The tag of the stream returning this buffer, for logging if necessary.</param>
+	/// <exception cref="ArgumentNullException">buffer is null</exception>
+	/// <exception cref="ArgumentException">
+	/// buffer.Length is not a multiple/exponential of LargeBufferMultiple (it did not
+	/// originate from this pool)
+	/// </exception>
+	internal void ReturnLargeBuffer(byte[] buffer, string tag)
+	{
+		if (buffer == null) throw new ArgumentNullException(nameof(buffer));
+
+		if (!IsLargeBufferSize(buffer.Length))
+			throw new ArgumentException(
+				string.Format("buffer did not originate from this memory manager. The size is not {0} of ",
+					UseExponentialLargeBuffer ? "an exponential" : "a multiple") +
+				LargeBufferMultiple);
 
-			var poolIndex = GetPoolIndex(buffer.Length);
+		var poolIndex = GetPoolIndex(buffer.Length);
 
-			if (poolIndex < _largePools.Length)
+		if (poolIndex < _largePools.Length)
+		{
+			if ((_largePools[poolIndex].Count + 1) * buffer.Length <= MaximumFreeLargePoolBytes ||
+				MaximumFreeLargePoolBytes == 0)
 			{
-				if ((_largePools[poolIndex].Count + 1) * buffer.Length <= MaximumFreeLargePoolBytes ||
-					MaximumFreeLargePoolBytes == 0)
-				{
-					_largePools[poolIndex].Push(buffer);
-					Interlocked.Add(ref _largeBufferFreeSize[poolIndex], buffer.Length);
-				}
-				else
-				{
-					EventsWriter.MemoryStreamDiscardBuffer(Events.MemoryStreamBufferType.Large, tag,
-						Events.MemoryStreamDiscardReason.EnoughFree);
-					ReportLargeBufferDiscarded(Events.MemoryStreamDiscardReason.EnoughFree);
-				}
+				_largePools[poolIndex].Push(buffer);
+				Interlocked.Add(ref _largeBufferFreeSize[poolIndex], buffer.Length);
 			}
 			else
 			{
-				// This is a non-poolable buffer, but we still want to track its size for inuse
-				// analysis. We have space in the inuse array for this.
-				poolIndex = _largeBufferInUseSize.Length - 1;
-
 				EventsWriter.MemoryStreamDiscardBuffer(Events.MemoryStreamBufferType.Large, tag,
-					Events.MemoryStreamDiscardReason.TooLarge);
-				ReportLargeBufferDiscarded(Events.MemoryStreamDiscardReason.TooLarge);
+					Events.MemoryStreamDiscardReason.EnoughFree);
+				ReportLargeBufferDiscarded(Events.MemoryStreamDiscardReason.EnoughFree);
 			}
+		}
+		else
+		{
+			// This is a non-poolable buffer, but we still want to track its size for inuse
+			// analysis. We have space in the inuse array for this.
+			poolIndex = _largeBufferInUseSize.Length - 1;
 
-			Interlocked.Add(ref _largeBufferInUseSize[poolIndex], -buffer.Length);
-
-			ReportUsageReport(_smallPoolInUseSize, _smallPoolFreeSize, LargePoolInUseSize,
-				LargePoolFreeSize);
+			EventsWriter.MemoryStreamDiscardBuffer(Events.MemoryStreamBufferType.Large, tag,
+				Events.MemoryStreamDiscardReason.TooLarge);
+			ReportLargeBufferDiscarded(Events.MemoryStreamDiscardReason.TooLarge);
 		}
 
-		/// <summary>
-		/// Returns the blocks to the pool
-		/// </summary>
-		/// <param name="blocks">Collection of blocks to return to the pool</param>
-		/// <param name="tag">The tag of the stream returning these blocks, for logging if necessary.</param>
-		/// <exception cref="ArgumentNullException">blocks is null</exception>
-		/// <exception cref="ArgumentException">blocks contains buffers that are the wrong size (or null) for this memory manager</exception>
-		internal void ReturnBlocks(ICollection<byte[]> blocks, string tag)
-		{
-			if (blocks == null) throw new ArgumentNullException(nameof(blocks));
+		Interlocked.Add(ref _largeBufferInUseSize[poolIndex], -buffer.Length);
+
+		ReportUsageReport(_smallPoolInUseSize, _smallPoolFreeSize, LargePoolInUseSize,
+			LargePoolFreeSize);
+	}
+
+	/// <summary>
+	/// Returns the blocks to the pool
+	/// </summary>
+	/// <param name="blocks">Collection of blocks to return to the pool</param>
+	/// <param name="tag">The tag of the stream returning these blocks, for logging if necessary.</param>
+	/// <exception cref="ArgumentNullException">blocks is null</exception>
+	/// <exception cref="ArgumentException">blocks contains buffers that are the wrong size (or null) for this memory manager</exception>
+	internal void ReturnBlocks(ICollection<byte[]> blocks, string tag)
+	{
+		if (blocks == null) throw new ArgumentNullException(nameof(blocks));
 
-			var bytesToReturn = blocks.Count * BlockSize;
-			Interlocked.Add(ref _smallPoolInUseSize, -bytesToReturn);
+		var bytesToReturn = blocks.Count * BlockSize;
+		Interlocked.Add(ref _smallPoolInUseSize, -bytesToReturn);
 
-			foreach (var block in blocks)
+		foreach (var block in blocks)
+		{
+			if (block == null || block.Length != BlockSize)
+				throw new ArgumentException("blocks contains buffers that are not BlockSize in length");
+		}
+
+		foreach (var block in blocks)
+		{
+			if (MaximumFreeSmallPoolBytes == 0 || SmallPoolFreeSize < MaximumFreeSmallPoolBytes)
 			{
-				if (block == null || block.Length != BlockSize)
-					throw new ArgumentException("blocks contains buffers that are not BlockSize in length");
+				Interlocked.Add(ref _smallPoolFreeSize, BlockSize);
+				_smallPool.Push(block);
 			}
-
-			foreach (var block in blocks)
+			else
 			{
-				if (MaximumFreeSmallPoolBytes == 0 || SmallPoolFreeSize < MaximumFreeSmallPoolBytes)
-				{
-					Interlocked.Add(ref _smallPoolFreeSize, BlockSize);
-					_smallPool.Push(block);
-				}
-				else
-				{
-					EventsWriter.MemoryStreamDiscardBuffer(Events.MemoryStreamBufferType.Small, tag,
-						Events.MemoryStreamDiscardReason.EnoughFree);
-					ReportBlockDiscarded();
-					break;
-				}
+				EventsWriter.MemoryStreamDiscardBuffer(Events.MemoryStreamBufferType.Small, tag,
+					Events.MemoryStreamDiscardReason.EnoughFree);
+				ReportBlockDiscarded();
+				break;
 			}
-
-			ReportUsageReport(_smallPoolInUseSize, _smallPoolFreeSize, LargePoolInUseSize,
-				LargePoolFreeSize);
 		}
 
-		internal void ReportBlockCreated() => BlockCreated?.Invoke();
+		ReportUsageReport(_smallPoolInUseSize, _smallPoolFreeSize, LargePoolInUseSize,
+			LargePoolFreeSize);
+	}
 
-		internal void ReportBlockDiscarded() => BlockDiscarded?.Invoke();
+	internal void ReportBlockCreated() => BlockCreated?.Invoke();
 
-		internal void ReportLargeBufferCreated() => LargeBufferCreated?.Invoke();
+	internal void ReportBlockDiscarded() => BlockDiscarded?.Invoke();
 
-		internal void ReportLargeBufferDiscarded(Events.MemoryStreamDiscardReason reason) => LargeBufferDiscarded?.Invoke(reason);
+	internal void ReportLargeBufferCreated() => LargeBufferCreated?.Invoke();
 
-		internal void ReportStreamCreated() => StreamCreated?.Invoke();
+	internal void ReportLargeBufferDiscarded(Events.MemoryStreamDiscardReason reason) => LargeBufferDiscarded?.Invoke(reason);
 
-		internal void ReportStreamDisposed() => StreamDisposed?.Invoke();
+	internal void ReportStreamCreated() => StreamCreated?.Invoke();
 
-		internal void ReportStreamFinalized() => StreamFinalized?.Invoke();
+	internal void ReportStreamDisposed() => StreamDisposed?.Invoke();
 
-		internal void ReportStreamLength(long bytes) => StreamLength?.Invoke(bytes);
+	internal void ReportStreamFinalized() => StreamFinalized?.Invoke();
 
-		internal void ReportStreamToArray() => StreamConvertedToArray?.Invoke();
+	internal void ReportStreamLength(long bytes) => StreamLength?.Invoke(bytes);
 
-		internal void ReportUsageReport(
-			long smallPoolInUseBytes, long smallPoolFreeBytes, long largePoolInUseBytes, long largePoolFreeBytes
-		) =>
-			UsageReport?.Invoke(smallPoolInUseBytes, smallPoolFreeBytes, largePoolInUseBytes, largePoolFreeBytes);
+	internal void ReportStreamToArray() => StreamConvertedToArray?.Invoke();
 
-		/// <summary>
-		/// Retrieve a new MemoryStream object with no tag and a default initial capacity.
-		/// </summary>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream() => new RecyclableMemoryStream(this);
+	internal void ReportUsageReport(
+		long smallPoolInUseBytes, long smallPoolFreeBytes, long largePoolInUseBytes, long largePoolFreeBytes
+	) =>
+		UsageReport?.Invoke(smallPoolInUseBytes, smallPoolFreeBytes, largePoolInUseBytes, largePoolFreeBytes);
 
-		private class ReportingMemoryStream : MemoryStream
-		{
-			private readonly RecyclableMemoryStreamManager _instance;
+	/// <summary>
+	/// Retrieve a new MemoryStream object with no tag and a default initial capacity.
+	/// </summary>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream() => new RecyclableMemoryStream(this);
 
-			public ReportingMemoryStream(byte[] bytes, RecyclableMemoryStreamManager instance) : base(bytes) => _instance = instance;
-		}
+	private class ReportingMemoryStream : MemoryStream
+	{
+		private readonly RecyclableMemoryStreamManager _instance;
 
-		/// <summary>
-		/// Shortcut to create a stream that directly wraps bytes but still uses reporting on the stream being created and disposes.
-		/// Note this does NOT use the pooled memory streams as the bytes have already been allocated
-		/// </summary>
-		public MemoryStream GetStream(byte[] bytes) => new ReportingMemoryStream(bytes, this);
-
-		/// <summary>
-		/// Retrieve a new MemoryStream object with no tag and a default initial capacity.
-		/// </summary>
-		/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream(Guid id) => new RecyclableMemoryStream(this, id);
-
-		/// <summary>
-		/// Retrieve a new MemoryStream object with the given tag and a default initial capacity.
-		/// </summary>
-		/// <param name="tag">A tag which can be used to track the source of the stream.</param>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream(string tag) => new RecyclableMemoryStream(this, tag);
-
-		/// <summary>
-		/// Retrieve a new MemoryStream object with the given tag and a default initial capacity.
-		/// </summary>
-		/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
-		/// <param name="tag">A tag which can be used to track the source of the stream.</param>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream(Guid id, string tag) => new RecyclableMemoryStream(this, id, tag);
-
-		/// <summary>
-		/// Retrieve a new MemoryStream object with the given tag and at least the given capacity.
-		/// </summary>
-		/// <param name="tag">A tag which can be used to track the source of the stream.</param>
-		/// <param name="requiredSize">The minimum desired capacity for the stream.</param>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream(string tag, int requiredSize) => new RecyclableMemoryStream(this, tag, requiredSize);
-
-		/// <summary>
-		/// Retrieve a new MemoryStream object with the given tag and at least the given capacity.
-		/// </summary>
-		/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
-		/// <param name="tag">A tag which can be used to track the source of the stream.</param>
-		/// <param name="requiredSize">The minimum desired capacity for the stream.</param>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream(Guid id, string tag, int requiredSize) => new RecyclableMemoryStream(this, id, tag, requiredSize);
-
-		/// <summary>
-		/// Retrieve a new MemoryStream object with the given tag and at least the given capacity, possibly using
-		/// a single contiguous underlying buffer.
-		/// </summary>
-		/// <remarks>
-		/// Retrieving a MemoryStream which provides a single contiguous buffer can be useful in situations
-		/// where the initial size is known and it is desirable to avoid copying data between the smaller underlying
-		/// buffers to a single large one. This is most helpful when you know that you will always call GetBuffer
-		/// on the underlying stream.
-		/// </remarks>
-		/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
-		/// <param name="tag">A tag which can be used to track the source of the stream.</param>
-		/// <param name="requiredSize">The minimum desired capacity for the stream.</param>
-		/// <param name="asContiguousBuffer">Whether to attempt to use a single contiguous buffer.</param>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream(Guid id, string tag, int requiredSize, bool asContiguousBuffer)
-		{
-			if (!asContiguousBuffer || requiredSize <= BlockSize) return GetStream(id, tag, requiredSize);
+		public ReportingMemoryStream(byte[] bytes, RecyclableMemoryStreamManager instance) : base(bytes) => _instance = instance;
+	}
 
-			return new RecyclableMemoryStream(this, id, tag, requiredSize, GetLargeBuffer(requiredSize, tag));
-		}
+	/// <summary>
+	/// Shortcut to create a stream that directly wraps bytes but still uses reporting on the stream being created and disposes.
+	/// Note this does NOT use the pooled memory streams as the bytes have already been allocated
+	/// </summary>
+	public MemoryStream GetStream(byte[] bytes) => new ReportingMemoryStream(bytes, this);
+
+	/// <summary>
+	/// Retrieve a new MemoryStream object with no tag and a default initial capacity.
+	/// </summary>
+	/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream(Guid id) => new RecyclableMemoryStream(this, id);
+
+	/// <summary>
+	/// Retrieve a new MemoryStream object with the given tag and a default initial capacity.
+	/// </summary>
+	/// <param name="tag">A tag which can be used to track the source of the stream.</param>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream(string tag) => new RecyclableMemoryStream(this, tag);
+
+	/// <summary>
+	/// Retrieve a new MemoryStream object with the given tag and a default initial capacity.
+	/// </summary>
+	/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+	/// <param name="tag">A tag which can be used to track the source of the stream.</param>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream(Guid id, string tag) => new RecyclableMemoryStream(this, id, tag);
+
+	/// <summary>
+	/// Retrieve a new MemoryStream object with the given tag and at least the given capacity.
+	/// </summary>
+	/// <param name="tag">A tag which can be used to track the source of the stream.</param>
+	/// <param name="requiredSize">The minimum desired capacity for the stream.</param>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream(string tag, int requiredSize) => new RecyclableMemoryStream(this, tag, requiredSize);
+
+	/// <summary>
+	/// Retrieve a new MemoryStream object with the given tag and at least the given capacity.
+	/// </summary>
+	/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+	/// <param name="tag">A tag which can be used to track the source of the stream.</param>
+	/// <param name="requiredSize">The minimum desired capacity for the stream.</param>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream(Guid id, string tag, int requiredSize) => new RecyclableMemoryStream(this, id, tag, requiredSize);
 
-		/// <summary>
-		/// Retrieve a new MemoryStream object with the given tag and at least the given capacity, possibly using
-		/// a single contiguous underlying buffer.
-		/// </summary>
-		/// <remarks>
-		/// Retrieving a MemoryStream which provides a single contiguous buffer can be useful in situations
-		/// where the initial size is known and it is desirable to avoid copying data between the smaller underlying
-		/// buffers to a single large one. This is most helpful when you know that you will always call GetBuffer
-		/// on the underlying stream.
-		/// </remarks>
-		/// <param name="tag">A tag which can be used to track the source of the stream.</param>
-		/// <param name="requiredSize">The minimum desired capacity for the stream.</param>
-		/// <param name="asContiguousBuffer">Whether to attempt to use a single contiguous buffer.</param>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream(string tag, int requiredSize, bool asContiguousBuffer) =>
-			GetStream(Guid.NewGuid(), tag, requiredSize, asContiguousBuffer);
-
-		/// <summary>
-		/// Retrieve a new MemoryStream object with the given tag and with contents copied from the provided
-		/// buffer. The provided buffer is not wrapped or used after construction.
-		/// </summary>
-		/// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
-		/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
-		/// <param name="tag">A tag which can be used to track the source of the stream.</param>
-		/// <param name="buffer">The byte buffer to copy data from.</param>
-		/// <param name="offset">The offset from the start of the buffer to copy from.</param>
-		/// <param name="count">The number of bytes to copy from the buffer.</param>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream(Guid id, string tag, byte[] buffer, int offset, int count)
+	/// <summary>
+	/// Retrieve a new MemoryStream object with the given tag and at least the given capacity, possibly using
+	/// a single contiguous underlying buffer.
+	/// </summary>
+	/// <remarks>
+	/// Retrieving a MemoryStream which provides a single contiguous buffer can be useful in situations
+	/// where the initial size is known and it is desirable to avoid copying data between the smaller underlying
+	/// buffers to a single large one. This is most helpful when you know that you will always call GetBuffer
+	/// on the underlying stream.
+	/// </remarks>
+	/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+	/// <param name="tag">A tag which can be used to track the source of the stream.</param>
+	/// <param name="requiredSize">The minimum desired capacity for the stream.</param>
+	/// <param name="asContiguousBuffer">Whether to attempt to use a single contiguous buffer.</param>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream(Guid id, string tag, int requiredSize, bool asContiguousBuffer)
+	{
+		if (!asContiguousBuffer || requiredSize <= BlockSize) return GetStream(id, tag, requiredSize);
+
+		return new RecyclableMemoryStream(this, id, tag, requiredSize, GetLargeBuffer(requiredSize, tag));
+	}
+
+	/// <summary>
+	/// Retrieve a new MemoryStream object with the given tag and at least the given capacity, possibly using
+	/// a single contiguous underlying buffer.
+	/// </summary>
+	/// <remarks>
+	/// Retrieving a MemoryStream which provides a single contiguous buffer can be useful in situations
+	/// where the initial size is known and it is desirable to avoid copying data between the smaller underlying
+	/// buffers to a single large one. This is most helpful when you know that you will always call GetBuffer
+	/// on the underlying stream.
+	/// </remarks>
+	/// <param name="tag">A tag which can be used to track the source of the stream.</param>
+	/// <param name="requiredSize">The minimum desired capacity for the stream.</param>
+	/// <param name="asContiguousBuffer">Whether to attempt to use a single contiguous buffer.</param>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream(string tag, int requiredSize, bool asContiguousBuffer) =>
+		GetStream(Guid.NewGuid(), tag, requiredSize, asContiguousBuffer);
+
+	/// <summary>
+	/// Retrieve a new MemoryStream object with the given tag and with contents copied from the provided
+	/// buffer. The provided buffer is not wrapped or used after construction.
+	/// </summary>
+	/// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
+	/// <param name="id">A unique identifier which can be used to trace usages of the stream.</param>
+	/// <param name="tag">A tag which can be used to track the source of the stream.</param>
+	/// <param name="buffer">The byte buffer to copy data from.</param>
+	/// <param name="offset">The offset from the start of the buffer to copy from.</param>
+	/// <param name="count">The number of bytes to copy from the buffer.</param>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream(Guid id, string tag, byte[] buffer, int offset, int count)
+	{
+		RecyclableMemoryStream stream = null;
+		try
 		{
-			RecyclableMemoryStream stream = null;
-			try
-			{
-				stream = new RecyclableMemoryStream(this, id, tag, count);
-				stream.Write(buffer, offset, count);
-				stream.Position = 0;
-				return stream;
-			}
-			catch
-			{
-				stream?.Dispose();
-				throw;
-			}
+			stream = new RecyclableMemoryStream(this, id, tag, count);
+			stream.Write(buffer, offset, count);
+			stream.Position = 0;
+			return stream;
+		}
+		catch
+		{
+			stream?.Dispose();
+			throw;
 		}
+	}
 
-		/// <summary>
-		/// Retrieve a new MemoryStream object with the given tag and with contents copied from the provided
-		/// buffer. The provided buffer is not wrapped or used after construction.
-		/// </summary>
-		/// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
-		/// <param name="tag">A tag which can be used to track the source of the stream.</param>
-		/// <param name="buffer">The byte buffer to copy data from.</param>
-		/// <param name="offset">The offset from the start of the buffer to copy from.</param>
-		/// <param name="count">The number of bytes to copy from the buffer.</param>
-		/// <returns>A MemoryStream.</returns>
-		public MemoryStream GetStream(string tag, byte[] buffer, int offset, int count) => GetStream(Guid.NewGuid(), tag, buffer, offset, count);
-
-		/// <summary>
-		/// Triggered when a new block is created.
-		/// </summary>
-		public event EventHandler BlockCreated;
-
-		/// <summary>
-		/// Triggered when a new block is created.
-		/// </summary>
-		public event EventHandler BlockDiscarded;
-
-		/// <summary>
-		/// Triggered when a new large buffer is created.
-		/// </summary>
-		public event EventHandler LargeBufferCreated;
-
-		/// <summary>
-		/// Triggered when a new stream is created.
-		/// </summary>
-		public event EventHandler StreamCreated;
-
-		/// <summary>
-		/// Triggered when a stream is disposed.
-		/// </summary>
-		public event EventHandler StreamDisposed;
-
-		/// <summary>
-		/// Triggered when a stream is finalized.
-		/// </summary>
-		public event EventHandler StreamFinalized;
-
-		/// <summary>
-		/// Triggered when a stream is finalized.
-		/// </summary>
-		public event StreamLengthReportHandler StreamLength;
-
-		/// <summary>
-		/// Triggered when a user converts a stream to array.
-		/// </summary>
-		public event EventHandler StreamConvertedToArray;
-
-		/// <summary>
-		/// Triggered when a large buffer is discarded, along with the reason for the discard.
-		/// </summary>
-		public event LargeBufferDiscardedEventHandler LargeBufferDiscarded;
-
-		/// <summary>
-		/// Periodically triggered to report usage statistics.
-		/// </summary>
-		public event UsageReportEventHandler UsageReport;
+	/// <summary>
+	/// Retrieve a new MemoryStream object with the given tag and with contents copied from the provided
+	/// buffer. The provided buffer is not wrapped or used after construction.
+	/// </summary>
+	/// <remarks>The new stream's position is set to the beginning of the stream when returned.</remarks>
+	/// <param name="tag">A tag which can be used to track the source of the stream.</param>
+	/// <param name="buffer">The byte buffer to copy data from.</param>
+	/// <param name="offset">The offset from the start of the buffer to copy from.</param>
+	/// <param name="count">The number of bytes to copy from the buffer.</param>
+	/// <returns>A MemoryStream.</returns>
+	public MemoryStream GetStream(string tag, byte[] buffer, int offset, int count) => GetStream(Guid.NewGuid(), tag, buffer, offset, count);
+
+	/// <summary>
+	/// Triggered when a new block is created.
+	/// </summary>
+	public event EventHandler BlockCreated;
+
+	/// <summary>
+	/// Triggered when a new block is created.
+	/// </summary>
+	public event EventHandler BlockDiscarded;
+
+	/// <summary>
+	/// Triggered when a new large buffer is created.
+	/// </summary>
+	public event EventHandler LargeBufferCreated;
+
+	/// <summary>
+	/// Triggered when a new stream is created.
+	/// </summary>
+	public event EventHandler StreamCreated;
+
+	/// <summary>
+	/// Triggered when a stream is disposed.
+	/// </summary>
+	public event EventHandler StreamDisposed;
+
+	/// <summary>
+	/// Triggered when a stream is finalized.
+	/// </summary>
+	public event EventHandler StreamFinalized;
+
+	/// <summary>
+	/// Triggered when a stream is finalized.
+	/// </summary>
+	public event StreamLengthReportHandler StreamLength;
+
+	/// <summary>
+	/// Triggered when a user converts a stream to array.
+	/// </summary>
+	public event EventHandler StreamConvertedToArray;
+
+	/// <summary>
+	/// Triggered when a large buffer is discarded, along with the reason for the discard.
+	/// </summary>
+	public event LargeBufferDiscardedEventHandler LargeBufferDiscarded;
+
+	/// <summary>
+	/// Periodically triggered to report usage statistics.
+	/// </summary>
+	public event UsageReportEventHandler UsageReport;
 
-	}
 }
diff --git a/src/Elastic.Transport/Components/Providers/RequestPipelineFactory.cs b/src/Elastic.Transport/Components/Providers/RequestPipelineFactory.cs
new file mode 100644
index 0000000..7c0ba62
--- /dev/null
+++ b/src/Elastic.Transport/Components/Providers/RequestPipelineFactory.cs
@@ -0,0 +1,16 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+namespace Elastic.Transport;
+
+/// <summary> A factory that creates instances of <see cref="RequestPipeline"/>, this factory exists so that transport can be tested. </summary>
+public abstract class RequestPipelineFactory<TConfiguration>
+	where TConfiguration : class, ITransportConfiguration
+{
+	internal RequestPipelineFactory() { }
+
+	/// <summary> Create an instance of <see cref="RequestPipeline"/> </summary>
+	public abstract RequestPipeline Create(TConfiguration configuration, DateTimeProvider dateTimeProvider,
+		MemoryStreamFactory memoryStreamFactory, RequestParameters requestParameters);
+}
diff --git a/src/Elastic.Transport/Components/Serialization/Converters/DynamicDictionaryConverter.cs b/src/Elastic.Transport/Components/Serialization/Converters/DynamicDictionaryConverter.cs
index 942bdc3..454cce4 100644
--- a/src/Elastic.Transport/Components/Serialization/Converters/DynamicDictionaryConverter.cs
+++ b/src/Elastic.Transport/Components/Serialization/Converters/DynamicDictionaryConverter.cs
@@ -9,40 +9,39 @@
 using System.Text.Json.Serialization;
 using JsonSerializer = System.Text.Json.JsonSerializer;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+internal class DynamicDictionaryConverter : JsonConverter<DynamicDictionary>
 {
-	internal class DynamicDictionaryConverter : JsonConverter<DynamicDictionary>
+	public override DynamicDictionary Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 	{
-		public override DynamicDictionary Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+		if (reader.TokenType == JsonTokenType.StartArray)
 		{
-			if (reader.TokenType == JsonTokenType.StartArray)
-			{
-				var array = JsonSerializer.Deserialize<object[]>(ref reader, options);
-				var arrayDict = new Dictionary<string, object>();
-				for (var i = 0; i < array.Length; i++)
-					arrayDict[i.ToString(CultureInfo.InvariantCulture)] = new DynamicValue(array[i]);
-				return DynamicDictionary.Create(arrayDict);
-			}
-			if (reader.TokenType != JsonTokenType.StartObject) throw new JsonException();
-
-			var dict = JsonSerializer.Deserialize<Dictionary<string, object>>(ref reader, options);
-			return DynamicDictionary.Create(dict);
+			var array = JsonSerializer.Deserialize<object[]>(ref reader, options);
+			var arrayDict = new Dictionary<string, object>();
+			for (var i = 0; i < array.Length; i++)
+				arrayDict[i.ToString(CultureInfo.InvariantCulture)] = new DynamicValue(array[i]);
+			return DynamicDictionary.Create(arrayDict);
 		}
+		if (reader.TokenType != JsonTokenType.StartObject) throw new JsonException();
 
-		public override void Write(Utf8JsonWriter writer, DynamicDictionary dictionary, JsonSerializerOptions options)
-		{
-			writer.WriteStartObject();
+		var dict = JsonSerializer.Deserialize<Dictionary<string, object>>(ref reader, options);
+		return DynamicDictionary.Create(dict);
+	}
 
-			foreach (var kvp in dictionary)
-			{
-				if (kvp.Value == null) continue;
+	public override void Write(Utf8JsonWriter writer, DynamicDictionary dictionary, JsonSerializerOptions options)
+	{
+		writer.WriteStartObject();
 
-				writer.WritePropertyName(kvp.Key);
+		foreach (var kvp in dictionary)
+		{
+			if (kvp.Value == null) continue;
 
-				JsonSerializer.Serialize(writer, kvp.Value?.Value, options);
-			}
+			writer.WritePropertyName(kvp.Key);
 
-			writer.WriteEndObject();
+			JsonSerializer.Serialize(writer, kvp.Value?.Value, options);
 		}
+
+		writer.WriteEndObject();
 	}
 }
diff --git a/src/Elastic.Transport/Components/Serialization/Converters/ErrorCauseConverter.cs b/src/Elastic.Transport/Components/Serialization/Converters/ErrorCauseConverter.cs
index ef09efe..5e704a5 100644
--- a/src/Elastic.Transport/Components/Serialization/Converters/ErrorCauseConverter.cs
+++ b/src/Elastic.Transport/Components/Serialization/Converters/ErrorCauseConverter.cs
@@ -10,211 +10,209 @@
 using Elastic.Transport.Extensions;
 using Elastic.Transport.Products.Elasticsearch;
 
-namespace Elastic.Transport
-{
-	internal class ErrorCauseConverter : ErrorCauseConverter<ErrorCause> { }
+namespace Elastic.Transport;
+
+internal class ErrorCauseConverter : ErrorCauseConverter<ErrorCause> { }
 
-	internal class ErrorConverter : ErrorCauseConverter<Error>
+internal class ErrorConverter : ErrorCauseConverter<Error>
+{
+	protected override bool ReadMore(ref Utf8JsonReader reader, JsonSerializerOptions options, string propertyName, Error errorCause)
 	{
-		protected override bool ReadMore(ref Utf8JsonReader reader, JsonSerializerOptions options, string propertyName, Error errorCause)
+		void ReadAssign<T>(ref Utf8JsonReader r, Action<Error, T> set) =>
+			set(errorCause, JsonSerializer.Deserialize<T>(ref r, options));
+		switch (propertyName)
 		{
-			void ReadAssign<T>(ref Utf8JsonReader r, Action<Error, T> set) =>
-				set(errorCause, JsonSerializer.Deserialize<T>(ref r, options));
-			switch (propertyName)
-			{
-				case "headers":
-					ReadAssign<Dictionary<string, string>>(ref reader, (e, v) => e.Headers = v);
-					return true;
+			case "headers":
+				ReadAssign<Dictionary<string, string>>(ref reader, (e, v) => e.Headers = v);
+				return true;
 
-				case "root_cause":
-					ReadAssign<IReadOnlyCollection<ErrorCause>>(ref reader, (e, v) => e.RootCause = v);
-					return true;
-				default:
-					return false;
+			case "root_cause":
+				ReadAssign<IReadOnlyCollection<ErrorCause>>(ref reader, (e, v) => e.RootCause = v);
+				return true;
+			default:
+				return false;
 
-			}
 		}
 	}
+}
 
-	internal class ErrorCauseConverter<TErrorCause> : JsonConverter<TErrorCause> where TErrorCause : ErrorCause, new()
+internal class ErrorCauseConverter<TErrorCause> : JsonConverter<TErrorCause> where TErrorCause : ErrorCause, new()
+{
+	public override TErrorCause Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 	{
-		public override TErrorCause Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+		if (reader.TokenType != JsonTokenType.StartObject)
 		{
-			if (reader.TokenType != JsonTokenType.StartObject)
-			{
-				return reader.TokenType == JsonTokenType.String
-					? new TErrorCause { Reason = reader.GetString() }
-					: null;
-			}
+			return reader.TokenType == JsonTokenType.String
+				? new TErrorCause { Reason = reader.GetString() }
+				: null;
+		}
 
-			var errorCause = new TErrorCause();
-			var additionalProperties = new Dictionary<string, object>();
-			errorCause.AdditionalProperties = additionalProperties;
+		var errorCause = new TErrorCause();
+		var additionalProperties = new Dictionary<string, object>();
+		errorCause.AdditionalProperties = additionalProperties;
 
-			void ReadAssign<T>(ref Utf8JsonReader r, Action<ErrorCause, T> set) =>
-				set(errorCause, JsonSerializer.Deserialize<T>(ref r, options));
-			void ReadAny(ref Utf8JsonReader r, string property, Action<ErrorCause, string, object> set) =>
-				set(errorCause, property, JsonSerializer.Deserialize<object>(ref r, options));
+		void ReadAssign<T>(ref Utf8JsonReader r, Action<ErrorCause, T> set) =>
+			set(errorCause, JsonSerializer.Deserialize<T>(ref r, options));
+		void ReadAny(ref Utf8JsonReader r, string property, Action<ErrorCause, string, object> set) =>
+			set(errorCause, property, JsonSerializer.Deserialize<object>(ref r, options));
 
-			while (reader.Read())
-			{
-				if (reader.TokenType == JsonTokenType.EndObject) return errorCause;
+		while (reader.Read())
+		{
+			if (reader.TokenType == JsonTokenType.EndObject) return errorCause;
 
-				if (reader.TokenType != JsonTokenType.PropertyName) throw new JsonException();
+			if (reader.TokenType != JsonTokenType.PropertyName) throw new JsonException();
 
-				var propertyName = reader.GetString();
-				switch (propertyName)
-				{
-					//case "bytes_limit":
-					//	ReadAssign<int?>(ref reader, (e, v) => e.BytesLimit = v);
-					//	break;
-					//case "bytes_wanted":
-					//	ReadAssign<int?>(ref reader, (e, v) => e.BytesWanted = v);
-					//	break;
-					case "caused_by":
-						ReadAssign<ErrorCause>(ref reader, (e, v) => e.CausedBy = v);
-						break;
-					//case "col":
-					//	ReadAssign<int?>(ref reader, (e, v) => e.Column = v);
-					//	break;
-					//case "failed_shards":
-					//	ReadAssign<IReadOnlyCollection<ShardFailure>>(ref reader, (e, v) => e.FailedShards = v);
-					//	break;
-					//case "grouped":
-					//	ReadAssign<bool?>(ref reader, (e, v) => e.Grouped = v);
-					//	break;
-					case "index":
-						ReadAssign<string>(ref reader, (e, v) => e.Index = v);
-						break;
-					case "index_uuid":
-						ReadAssign<string>(ref reader, (e, v) => e.IndexUUID = v);
-						break;
-					//case "lang":
-					//	ReadAssign<string>(ref reader, (e, v) => e.Language = v);
-					//	break;
-					//case "license.expired.feature":
-					//	ReadAssign<string>(ref reader, (e, v) => e.LicensedExpiredFeature = v);
-					//	break;
-					//case "line":
-					//	ReadAssign<int?>(ref reader, (e, v) => e.Line = v);
-					//	break;
-					//case "phase":
-					//	ReadAssign<string>(ref reader, (e, v) => e.Phase = v);
-					//	break;
-					case "reason":
-						ReadAssign<string>(ref reader, (e, v) => e.Reason = v);
-						break;
-					//case "resource.id":
-					//	errorCause.ResourceId = ReadSingleOrCollection(ref reader, options);
-					//	break;
-					//case "resource.type":
-					//	ReadAssign<string>(ref reader, (e, v) => e.ResourceType = v);
-					//	break;
-					//case "script":
-					//	ReadAssign<string>(ref reader, (e, v) => e.Script = v);
-					//	break;
-					//case "script_stack":
-					//	errorCause.ScriptStack = ReadSingleOrCollection(ref reader, options);
-					//	break;
-					//case "shard":
-					//	errorCause.Shard = ReadIntFromString(ref reader, options);
-					//	break;
-					case "stack_trace":
-						ReadAssign<string>(ref reader, (e, v) => e.StackTrace = v);
-						break;
-					case "type":
-						ReadAssign<string>(ref reader, (e, v) => e.Type = v);
+			var propertyName = reader.GetString();
+			switch (propertyName)
+			{
+				//case "bytes_limit":
+				//	ReadAssign<int?>(ref reader, (e, v) => e.BytesLimit = v);
+				//	break;
+				//case "bytes_wanted":
+				//	ReadAssign<int?>(ref reader, (e, v) => e.BytesWanted = v);
+				//	break;
+				case "caused_by":
+					ReadAssign<ErrorCause>(ref reader, (e, v) => e.CausedBy = v);
+					break;
+				//case "col":
+				//	ReadAssign<int?>(ref reader, (e, v) => e.Column = v);
+				//	break;
+				//case "failed_shards":
+				//	ReadAssign<IReadOnlyCollection<ShardFailure>>(ref reader, (e, v) => e.FailedShards = v);
+				//	break;
+				//case "grouped":
+				//	ReadAssign<bool?>(ref reader, (e, v) => e.Grouped = v);
+				//	break;
+				case "index":
+					ReadAssign<string>(ref reader, (e, v) => e.Index = v);
+					break;
+				case "index_uuid":
+					ReadAssign<string>(ref reader, (e, v) => e.IndexUUID = v);
+					break;
+				//case "lang":
+				//	ReadAssign<string>(ref reader, (e, v) => e.Language = v);
+				//	break;
+				//case "license.expired.feature":
+				//	ReadAssign<string>(ref reader, (e, v) => e.LicensedExpiredFeature = v);
+				//	break;
+				//case "line":
+				//	ReadAssign<int?>(ref reader, (e, v) => e.Line = v);
+				//	break;
+				//case "phase":
+				//	ReadAssign<string>(ref reader, (e, v) => e.Phase = v);
+				//	break;
+				case "reason":
+					ReadAssign<string>(ref reader, (e, v) => e.Reason = v);
+					break;
+				//case "resource.id":
+				//	errorCause.ResourceId = ReadSingleOrCollection(ref reader, options);
+				//	break;
+				//case "resource.type":
+				//	ReadAssign<string>(ref reader, (e, v) => e.ResourceType = v);
+				//	break;
+				//case "script":
+				//	ReadAssign<string>(ref reader, (e, v) => e.Script = v);
+				//	break;
+				//case "script_stack":
+				//	errorCause.ScriptStack = ReadSingleOrCollection(ref reader, options);
+				//	break;
+				//case "shard":
+				//	errorCause.Shard = ReadIntFromString(ref reader, options);
+				//	break;
+				case "stack_trace":
+					ReadAssign<string>(ref reader, (e, v) => e.StackTrace = v);
+					break;
+				case "type":
+					ReadAssign<string>(ref reader, (e, v) => e.Type = v);
+					break;
+				default:
+					if (ReadMore(ref reader, options, propertyName, errorCause)) break;
+					else
+					{
+						ReadAny(ref reader, propertyName, (e, p, v) => additionalProperties.Add(p, v));
 						break;
-					default:
-						if (ReadMore(ref reader, options, propertyName, errorCause)) break;
-						else
-						{
-							ReadAny(ref reader, propertyName, (e, p, v) => additionalProperties.Add(p, v));
-							break;
-						}
-				}
+					}
 			}
-			return errorCause;
 		}
+		return errorCause;
+	}
 
-
-		private static int? ReadIntFromString(ref Utf8JsonReader reader, JsonSerializerOptions options)
+	private static int? ReadIntFromString(ref Utf8JsonReader reader, JsonSerializerOptions options)
+	{
+		reader.Read();
+		switch (reader.TokenType)
 		{
-			reader.Read();
-			switch (reader.TokenType)
-			{
-				case JsonTokenType.Null: return null;
-				case JsonTokenType.Number:
-					return JsonSerializer.Deserialize<int?>(ref reader, options);
-				case JsonTokenType.String:
-					var s = JsonSerializer.Deserialize<string>(ref reader, options);
-					if (int.TryParse(s, out var i)) return i;
-					return null;
-				default:
-					reader.TrySkip();
-					return null;
-			}
+			case JsonTokenType.Null: return null;
+			case JsonTokenType.Number:
+				return JsonSerializer.Deserialize<int?>(ref reader, options);
+			case JsonTokenType.String:
+				var s = JsonSerializer.Deserialize<string>(ref reader, options);
+				if (int.TryParse(s, out var i)) return i;
+				return null;
+			default:
+				reader.TrySkip();
+				return null;
 		}
+	}
 
-		private static IReadOnlyCollection<string> ReadSingleOrCollection(ref Utf8JsonReader reader, JsonSerializerOptions options)
+	private static IReadOnlyCollection<string> ReadSingleOrCollection(ref Utf8JsonReader reader, JsonSerializerOptions options)
+	{
+		reader.Read();
+		switch (reader.TokenType)
 		{
-			reader.Read();
-			switch (reader.TokenType)
-			{
-				case JsonTokenType.Null: return EmptyReadOnly<string>.Collection;
-				case JsonTokenType.StartArray:
-					var list = new List<string>();
-					while (reader.Read())
-					{
-						if (reader.TokenType == JsonTokenType.EndArray)
-							break;
-						list.Add(JsonSerializer.Deserialize<string>(ref reader, options));
-					}
-					return new ReadOnlyCollection<string>(list);
-				default:
-					var v = JsonSerializer.Deserialize<string>(ref reader, options);
-					return new ReadOnlyCollection<string>(new List<string>(1) { v});
-			}
+			case JsonTokenType.Null: return EmptyReadOnly<string>.Collection;
+			case JsonTokenType.StartArray:
+				var list = new List<string>();
+				while (reader.Read())
+				{
+					if (reader.TokenType == JsonTokenType.EndArray)
+						break;
+					list.Add(JsonSerializer.Deserialize<string>(ref reader, options));
+				}
+				return new ReadOnlyCollection<string>(list);
+			default:
+				var v = JsonSerializer.Deserialize<string>(ref reader, options);
+				return new ReadOnlyCollection<string>(new List<string>(1) { v});
 		}
+	}
 
-		protected virtual bool ReadMore(ref Utf8JsonReader reader, JsonSerializerOptions options, string propertyName, TErrorCause errorCause) => false;
-
-		public override void Write(Utf8JsonWriter writer, TErrorCause value, JsonSerializerOptions options)
-		{
-			writer.WriteStartObject();
+	protected virtual bool ReadMore(ref Utf8JsonReader reader, JsonSerializerOptions options, string propertyName, TErrorCause errorCause) => false;
 
-			static void Serialize<T>(Utf8JsonWriter writer, JsonSerializerOptions options, string name, T value)
-			{
-				if (value == null) return;
+	public override void Write(Utf8JsonWriter writer, TErrorCause value, JsonSerializerOptions options)
+	{
+		writer.WriteStartObject();
 
-				writer.WritePropertyName(name);
-				JsonSerializer.Serialize(writer, value, options);
-			}
+		static void Serialize<T>(Utf8JsonWriter writer, JsonSerializerOptions options, string name, T value)
+		{
+			if (value == null) return;
 
-			//Serialize(writer, options, "bytes_limit", value.BytesLimit);
-			//Serialize(writer, options, "bytes_wanted", value.BytesWanted);
-			Serialize(writer, options, "caused_by", value.CausedBy);
-			//Serialize(writer, options, "col", value.Column);
-			//Serialize(writer, options, "failed_shards", value.FailedShards);
-			//Serialize(writer, options, "grouped", value.Grouped);
-			Serialize(writer, options, "index", value.Index);
-			Serialize(writer, options, "index_uuid", value.IndexUUID);
-			//Serialize(writer, options, "lang", value.Language);
-			//Serialize(writer, options, "license.expired.feature", value.LicensedExpiredFeature);
-			//Serialize(writer, options, "line", value.Line);
-			//Serialize(writer, options, "phase", value.Phase);
-			//Serialize(writer, options, "reason", value.Reason);
-			//Serialize(writer, options, "resource.id", value.ResourceId);
-			//Serialize(writer, options, "resource.type", value.ResourceType);
-			//Serialize(writer, options, "script", value.Script);
-			//Serialize(writer, options, "script_stack", value.ScriptStack);
-			//Serialize(writer, options, "shard", value.Shard);
-			Serialize(writer, options, "stack_trace", value.StackTrace);
-			Serialize(writer, options, "type", value.Type);
-
-			foreach (var kv in value.AdditionalProperties)
-				Serialize(writer, options, kv.Key, kv.Value);
-			writer.WriteEndObject();
+			writer.WritePropertyName(name);
+			JsonSerializer.Serialize(writer, value, options);
 		}
+
+		//Serialize(writer, options, "bytes_limit", value.BytesLimit);
+		//Serialize(writer, options, "bytes_wanted", value.BytesWanted);
+		Serialize(writer, options, "caused_by", value.CausedBy);
+		//Serialize(writer, options, "col", value.Column);
+		//Serialize(writer, options, "failed_shards", value.FailedShards);
+		//Serialize(writer, options, "grouped", value.Grouped);
+		Serialize(writer, options, "index", value.Index);
+		Serialize(writer, options, "index_uuid", value.IndexUUID);
+		//Serialize(writer, options, "lang", value.Language);
+		//Serialize(writer, options, "license.expired.feature", value.LicensedExpiredFeature);
+		//Serialize(writer, options, "line", value.Line);
+		//Serialize(writer, options, "phase", value.Phase);
+		//Serialize(writer, options, "reason", value.Reason);
+		//Serialize(writer, options, "resource.id", value.ResourceId);
+		//Serialize(writer, options, "resource.type", value.ResourceType);
+		//Serialize(writer, options, "script", value.Script);
+		//Serialize(writer, options, "script_stack", value.ScriptStack);
+		//Serialize(writer, options, "shard", value.Shard);
+		Serialize(writer, options, "stack_trace", value.StackTrace);
+		Serialize(writer, options, "type", value.Type);
+
+		foreach (var kv in value.AdditionalProperties)
+			Serialize(writer, options, kv.Key, kv.Value);
+		writer.WriteEndObject();
 	}
 }
diff --git a/src/Elastic.Transport/Components/Serialization/Converters/ExceptionConverter.cs b/src/Elastic.Transport/Components/Serialization/Converters/ExceptionConverter.cs
index 35160fe..a635f0a 100644
--- a/src/Elastic.Transport/Components/Serialization/Converters/ExceptionConverter.cs
+++ b/src/Elastic.Transport/Components/Serialization/Converters/ExceptionConverter.cs
@@ -11,113 +11,112 @@
 using System.Text.Json.Serialization;
 using JsonSerializer = System.Text.Json.JsonSerializer;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A Json Converter that serializes an exception by flattening it and
+/// inner exceptions into an array of objects, including depth.
+/// </summary>
+internal class ExceptionConverter : JsonConverter<Exception>
 {
-	/// <summary>
-	/// A Json Converter that serializes an exception by flattening it and
-	/// inner exceptions into an array of objects, including depth.
-	/// </summary>
-	internal class ExceptionConverter : JsonConverter<Exception>
+	private static List<Dictionary<string, object>> FlattenExceptions(Exception e)
 	{
-		private static List<Dictionary<string, object>> FlattenExceptions(Exception e)
+		var maxExceptions = 20;
+		var exceptions = new List<Dictionary<string, object>>(maxExceptions);
+		var depth = 0;
+		do
 		{
-			var maxExceptions = 20;
-			var exceptions = new List<Dictionary<string, object>>(maxExceptions);
-			var depth = 0;
-			do
-			{
-				var o = ToDictionary(e, depth);
-				exceptions.Add(o);
-				depth++;
-				e = e.InnerException;
-			} while (depth < maxExceptions && e != null);
+			var o = ToDictionary(e, depth);
+			exceptions.Add(o);
+			depth++;
+			e = e.InnerException;
+		} while (depth < maxExceptions && e != null);
 
-			return exceptions;
-		}
+		return exceptions;
+	}
 
-		private static Dictionary<string, object> ToDictionary(Exception e, int depth)
-		{
-			var o = new Dictionary<string, object>(10);
-			var si = new SerializationInfo(e.GetType(), new FormatterConverter());
-			var sc = new StreamingContext();
-			e.GetObjectData(si, sc);
-
-			var helpUrl = si.GetString("HelpURL");
-			var stackTrace = si.GetString("StackTraceString");
-			var remoteStackTrace = si.GetString("RemoteStackTraceString");
-			var remoteStackIndex = si.GetInt32("RemoteStackIndex");
-			var exceptionMethod = si.GetString("ExceptionMethod");
-			var hresult = si.GetInt32("HResult");
-			var source = si.GetString("Source");
-			var className = si.GetString("ClassName");
-
-			o.Add("Depth", depth);
-			o.Add("ClassName", className);
-			o.Add("Message", e.Message);
-			o.Add("Source", source);
-			o.Add("StackTraceString", stackTrace);
-			o.Add("RemoteStackTraceString", remoteStackTrace);
-			o.Add("RemoteStackIndex", remoteStackIndex);
-			o.Add("HResult", hresult);
-			o.Add("HelpURL", helpUrl);
-
-			WriteStructuredExceptionMethod(o, exceptionMethod);
-			return o;
-		}
+	private static Dictionary<string, object> ToDictionary(Exception e, int depth)
+	{
+		var o = new Dictionary<string, object>(10);
+		var si = new SerializationInfo(e.GetType(), new FormatterConverter());
+		var sc = new StreamingContext();
+		e.GetObjectData(si, sc);
 
-		private static void WriteStructuredExceptionMethod(Dictionary<string, object> o, string exceptionMethodString)
-		{
-			if (string.IsNullOrWhiteSpace(exceptionMethodString)) return;
+		var helpUrl = si.GetString("HelpURL");
+		var stackTrace = si.GetString("StackTraceString");
+		var remoteStackTrace = si.GetString("RemoteStackTraceString");
+		var remoteStackIndex = si.GetInt32("RemoteStackIndex");
+		var exceptionMethod = si.GetString("ExceptionMethod");
+		var hresult = si.GetInt32("HResult");
+		var source = si.GetString("Source");
+		var className = si.GetString("ClassName");
 
-			var args = exceptionMethodString.Split('\0', '\n');
+		o.Add("Depth", depth);
+		o.Add("ClassName", className);
+		o.Add("Message", e.Message);
+		o.Add("Source", source);
+		o.Add("StackTraceString", stackTrace);
+		o.Add("RemoteStackTraceString", remoteStackTrace);
+		o.Add("RemoteStackIndex", remoteStackIndex);
+		o.Add("HResult", hresult);
+		o.Add("HelpURL", helpUrl);
 
-			if (args.Length != 5) return;
+		WriteStructuredExceptionMethod(o, exceptionMethod);
+		return o;
+	}
 
-			var memberType = int.Parse(args[0], CultureInfo.InvariantCulture);
-			var name = args[1];
-			var assemblyName = args[2];
-			var className = args[3];
-			var signature = args[4];
-			var an = new AssemblyName(assemblyName);
-			var exceptionMethod = new Dictionary<string, object>(7)
-			{
-				{ "Name", name },
-				{ "AssemblyName", an.Name },
-				{ "AssemblyVersion", an.Version.ToString() },
-				{ "AssemblyCulture", an.CultureName },
-				{ "ClassName", className },
-				{ "Signature", signature },
-				{ "MemberType", memberType }
-			};
-
-			o.Add("ExceptionMethod", exceptionMethod);
-		}
+	private static void WriteStructuredExceptionMethod(Dictionary<string, object> o, string exceptionMethodString)
+	{
+		if (string.IsNullOrWhiteSpace(exceptionMethodString)) return;
 
-		public override Exception Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
-			throw new NotSupportedException();
+		var args = exceptionMethodString.Split('\0', '\n');
 
-		public override void Write(Utf8JsonWriter writer, Exception value, JsonSerializerOptions options)
+		if (args.Length != 5) return;
+
+		var memberType = int.Parse(args[0], CultureInfo.InvariantCulture);
+		var name = args[1];
+		var assemblyName = args[2];
+		var className = args[3];
+		var signature = args[4];
+		var an = new AssemblyName(assemblyName);
+		var exceptionMethod = new Dictionary<string, object>(7)
 		{
-			if (value == null)
-			{
-				writer.WriteNullValue();
-				return;
-			}
+			{ "Name", name },
+			{ "AssemblyName", an.Name },
+			{ "AssemblyVersion", an.Version.ToString() },
+			{ "AssemblyCulture", an.CultureName },
+			{ "ClassName", className },
+			{ "Signature", signature },
+			{ "MemberType", memberType }
+		};
+
+		o.Add("ExceptionMethod", exceptionMethod);
+	}
+
+	public override Exception Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options) =>
+		throw new NotSupportedException();
 
-			var flattenedExceptions = FlattenExceptions(value);
-			writer.WriteStartArray();
-			for (var i = 0; i < flattenedExceptions.Count; i++)
+	public override void Write(Utf8JsonWriter writer, Exception value, JsonSerializerOptions options)
+	{
+		if (value == null)
+		{
+			writer.WriteNullValue();
+			return;
+		}
+
+		var flattenedExceptions = FlattenExceptions(value);
+		writer.WriteStartArray();
+		for (var i = 0; i < flattenedExceptions.Count; i++)
+		{
+			var flattenedException = flattenedExceptions[i];
+			writer.WriteStartObject();
+			foreach (var kv in flattenedException)
 			{
-				var flattenedException = flattenedExceptions[i];
-				writer.WriteStartObject();
-				foreach (var kv in flattenedException)
-				{
-					writer.WritePropertyName(kv.Key);
-					JsonSerializer.Serialize(writer, kv.Value, options);
-				}
-				writer.WriteEndObject();
+				writer.WritePropertyName(kv.Key);
+				JsonSerializer.Serialize(writer, kv.Value, options);
 			}
-			writer.WriteEndArray();
+			writer.WriteEndObject();
 		}
+		writer.WriteEndArray();
 	}
 }
diff --git a/src/Elastic.Transport/Components/Serialization/DiagnosticsSerializerProxy.cs b/src/Elastic.Transport/Components/Serialization/DiagnosticsSerializerProxy.cs
index dfaf27d..94a179c 100644
--- a/src/Elastic.Transport/Components/Serialization/DiagnosticsSerializerProxy.cs
+++ b/src/Elastic.Transport/Components/Serialization/DiagnosticsSerializerProxy.cs
@@ -9,75 +9,74 @@
 using System.Threading.Tasks;
 using Elastic.Transport.Diagnostics;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Wraps configured serializer so that we can emit diagnostics per configured serializer.
+/// </summary>
+internal class DiagnosticsSerializerProxy : Serializer
 {
+	private readonly Serializer _serializer;
+	private readonly SerializerRegistrationInformation _state;
+	private static DiagnosticSource DiagnosticSource { get; } = new DiagnosticListener(DiagnosticSources.Serializer.SourceName);
+
 	/// <summary>
-	/// Wraps configured serializer so that we can emit diagnostics per configured serializer.
+	/// <inheritdoc cref="DiagnosticsSerializerProxy" path="/summary"/>
 	/// </summary>
-	internal class DiagnosticsSerializerProxy : Serializer
+	/// <param name="serializer">The serializer we are proxying</param>
+	/// <param name="purpose"><inheritdoc cref="SerializerRegistrationInformation.Purpose" path="/summary"/></param>
+	public DiagnosticsSerializerProxy(Serializer serializer, string purpose = "request/response")
 	{
-		private readonly Serializer _serializer;
-		private readonly SerializerRegistrationInformation _state;
-		private static DiagnosticSource DiagnosticSource { get; } = new DiagnosticListener(DiagnosticSources.Serializer.SourceName);
-
-		/// <summary>
-		/// <inheritdoc cref="DiagnosticsSerializerProxy" path="/summary"/>
-		/// </summary>
-		/// <param name="serializer">The serializer we are proxying</param>
-		/// <param name="purpose"><inheritdoc cref="SerializerRegistrationInformation.Purpose" path="/summary"/></param>
-		public DiagnosticsSerializerProxy(Serializer serializer, string purpose = "request/response")
-		{
-			_serializer = serializer;
-			_state = new SerializerRegistrationInformation(serializer.GetType(), purpose);
-		}
+		_serializer = serializer;
+		_state = new SerializerRegistrationInformation(serializer.GetType(), purpose);
+	}
 
-		/// <summary>
-		/// Access to the inner <see cref="Serializer"/> wrapped by this proxy.
-		/// </summary>
-		public Serializer InnerSerializer => _serializer;
+	/// <summary>
+	/// Access to the inner <see cref="Serializer"/> wrapped by this proxy.
+	/// </summary>
+	public Serializer InnerSerializer => _serializer;
 
-		/// <inheritdoc cref="Serializer.Deserialize"/>>
-		public override object Deserialize(Type type, Stream stream)
-		{
-			using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Deserialize, _state))
-				return _serializer.Deserialize(type, stream);
-		}
+	/// <inheritdoc cref="Serializer.Deserialize"/>>
+	public override object Deserialize(Type type, Stream stream)
+	{
+		using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Deserialize, _state))
+			return _serializer.Deserialize(type, stream);
+	}
 
-		/// <inheritdoc cref="Serializer.Deserialize{T}"/>>
-		public override T Deserialize<T>(Stream stream)
-		{
-			using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Deserialize, _state))
-				return _serializer.Deserialize<T>(stream);
-		}
+	/// <inheritdoc cref="Serializer.Deserialize{T}"/>>
+	public override T Deserialize<T>(Stream stream)
+	{
+		using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Deserialize, _state))
+			return _serializer.Deserialize<T>(stream);
+	}
 
-		/// <inheritdoc cref="Serializer.DeserializeAsync"/>>
-		public override ValueTask<object> DeserializeAsync(Type type, Stream stream, CancellationToken cancellationToken = default)
-		{
-			using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Deserialize, _state))
-				return _serializer.DeserializeAsync(type, stream, cancellationToken);
-		}
+	/// <inheritdoc cref="Serializer.DeserializeAsync"/>>
+	public override ValueTask<object> DeserializeAsync(Type type, Stream stream, CancellationToken cancellationToken = default)
+	{
+		using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Deserialize, _state))
+			return _serializer.DeserializeAsync(type, stream, cancellationToken);
+	}
 
-		/// <inheritdoc cref="Serializer.DeserializeAsync{T}"/>>
-		public override ValueTask<T> DeserializeAsync<T>(Stream stream, CancellationToken cancellationToken = default)
-		{
-			using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Deserialize, _state))
-				return _serializer.DeserializeAsync<T>(stream, cancellationToken);
-		}
+	/// <inheritdoc cref="Serializer.DeserializeAsync{T}"/>>
+	public override ValueTask<T> DeserializeAsync<T>(Stream stream, CancellationToken cancellationToken = default)
+	{
+		using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Deserialize, _state))
+			return _serializer.DeserializeAsync<T>(stream, cancellationToken);
+	}
 
-		/// <inheritdoc cref="Serializer.Serialize{T}"/>>
-		public override void Serialize<T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.None)
-		{
-			using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Serialize, _state))
-				_serializer.Serialize(data, stream, formatting);
-		}
+	/// <inheritdoc cref="Serializer.Serialize{T}"/>>
+	public override void Serialize<T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.None)
+	{
+		using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Serialize, _state))
+			_serializer.Serialize(data, stream, formatting);
+	}
 
-		/// <inheritdoc cref="Serializer.SerializeAsync{T}"/>>
-		public override Task SerializeAsync<T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.None,
-			CancellationToken cancellationToken = default
-		)
-		{
-			using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Serialize, _state))
-				return _serializer.SerializeAsync(data, stream, formatting, cancellationToken);
-		}
+	/// <inheritdoc cref="Serializer.SerializeAsync{T}"/>>
+	public override Task SerializeAsync<T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.None,
+		CancellationToken cancellationToken = default
+	)
+	{
+		using (DiagnosticSource.Diagnose(DiagnosticSources.Serializer.Serialize, _state))
+			return _serializer.SerializeAsync(data, stream, formatting, cancellationToken);
 	}
 }
diff --git a/src/Elastic.Transport/Components/Serialization/JsonElementExtensions.cs b/src/Elastic.Transport/Components/Serialization/JsonElementExtensions.cs
index b6058ba..0737900 100644
--- a/src/Elastic.Transport/Components/Serialization/JsonElementExtensions.cs
+++ b/src/Elastic.Transport/Components/Serialization/JsonElementExtensions.cs
@@ -7,32 +7,31 @@
 using System.Linq;
 using System.Text.Json;
 
-namespace Elastic.Transport.Extensions
+namespace Elastic.Transport.Extensions;
+
+internal static class JsonElementExtensions
 {
-	internal static class JsonElementExtensions
-	{
-		/// <summary>
-		/// Fully consumes a json element representing a json object. Meaning it will attempt to unwrap all JsonElement values
-		/// recursively to their actual types. This should only be used in the context of <see cref="DynamicDictionary"/> which is
-		/// allowed to be slow yet convenient
-		/// </summary>
-		public static IDictionary<string, object> ToDictionary(this JsonElement e) =>
-			e.ValueKind switch
-			{
-				JsonValueKind.Object => e.EnumerateObject()
-					.Aggregate(new Dictionary<string, object>(), (dict, je) =>
-					{
-						dict.Add(je.Name, DynamicValue.ConsumeJsonElement(typeof(object), je.Value));
-						return dict;
-					}),
-				JsonValueKind.Array => e.EnumerateArray()
-					.Select((je, i) => (i, o: DynamicValue.ConsumeJsonElement(typeof(object), je)))
-					.Aggregate(new Dictionary<string, object>(), (dict, t) =>
-					{
-						dict.Add(t.i.ToString(CultureInfo.InvariantCulture), t.o);
-						return dict;
-					}),
-				_ => null
-			};
-	}
+	/// <summary>
+	/// Fully consumes a json element representing a json object. Meaning it will attempt to unwrap all JsonElement values
+	/// recursively to their actual types. This should only be used in the context of <see cref="DynamicDictionary"/> which is
+	/// allowed to be slow yet convenient
+	/// </summary>
+	public static IDictionary<string, object> ToDictionary(this JsonElement e) =>
+		e.ValueKind switch
+		{
+			JsonValueKind.Object => e.EnumerateObject()
+				.Aggregate(new Dictionary<string, object>(), (dict, je) =>
+				{
+					dict.Add(je.Name, DynamicValue.ConsumeJsonElement(typeof(object), je.Value));
+					return dict;
+				}),
+			JsonValueKind.Array => e.EnumerateArray()
+				.Select((je, i) => (i, o: DynamicValue.ConsumeJsonElement(typeof(object), je)))
+				.Aggregate(new Dictionary<string, object>(), (dict, t) =>
+				{
+					dict.Add(t.i.ToString(CultureInfo.InvariantCulture), t.o);
+					return dict;
+				}),
+			_ => null
+		};
 }
diff --git a/src/Elastic.Transport/Components/Serialization/LowLevelRequestResponseSerializer.cs b/src/Elastic.Transport/Components/Serialization/LowLevelRequestResponseSerializer.cs
index fc46592..6c53bcf 100644
--- a/src/Elastic.Transport/Components/Serialization/LowLevelRequestResponseSerializer.cs
+++ b/src/Elastic.Transport/Components/Serialization/LowLevelRequestResponseSerializer.cs
@@ -21,7 +21,7 @@ namespace Elastic.Transport;
 /// </summary>
 public class LowLevelRequestResponseSerializer : Serializer
 {
-	//TODO explore removing this or make internal, this provides a path that circumvents the configured ITransportSerializer
+	//TODO explore removing this or make internal, this provides a path that circumvents the configured HttpTransportSerializer
 	/// <summary> Provides a static reusable reference to an instance of <see cref="LowLevelRequestResponseSerializer"/> to promote reuse </summary>
 	public static readonly LowLevelRequestResponseSerializer Instance = new();
 
diff --git a/src/Elastic.Transport/Components/Serialization/SerializationFormatting.cs b/src/Elastic.Transport/Components/Serialization/SerializationFormatting.cs
index 039d148..e438bb9 100644
--- a/src/Elastic.Transport/Components/Serialization/SerializationFormatting.cs
+++ b/src/Elastic.Transport/Components/Serialization/SerializationFormatting.cs
@@ -2,24 +2,23 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A hint to <see cref="Serializer"/> how to format the json.
+/// Implementation of <see cref="Serializer"/> might choose to ignore this hint though.
+/// </summary>
+public enum SerializationFormatting
 {
 	/// <summary>
-	/// A hint to <see cref="Serializer"/> how to format the json.
-	/// Implementation of <see cref="Serializer"/> might choose to ignore this hint though.
+	/// Serializer should not render the json with whitespace and line endings. <see cref="Serializer"/>
+	/// implementation HAVE to be able to adhere this value as for instance nd-json relies on this
 	/// </summary>
-	public enum SerializationFormatting
-	{
-		/// <summary>
-		/// Serializer should not render the json with whitespace and line endings. <see cref="Serializer"/>
-		/// implementation HAVE to be able to adhere this value as for instance nd-json relies on this
-		/// </summary>
-		None,
+	None,
 
-		/// <summary>
-		/// A hint that the user prefers readable data being written. <see cref="Serializer"/> implementations
-		/// should try to adhere to this but won't break anything if they don't.
-		/// </summary>
-		Indented
-	}
+	/// <summary>
+	/// A hint that the user prefers readable data being written. <see cref="Serializer"/> implementations
+	/// should try to adhere to this but won't break anything if they don't.
+	/// </summary>
+	Indented
 }
diff --git a/src/Elastic.Transport/Components/Serialization/Serializer.cs b/src/Elastic.Transport/Components/Serialization/Serializer.cs
index 3607764..fa996fc 100644
--- a/src/Elastic.Transport/Components/Serialization/Serializer.cs
+++ b/src/Elastic.Transport/Components/Serialization/Serializer.cs
@@ -7,48 +7,47 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// When the <see cref="HttpTransport{TConnectionSettings}"/> needs to (de)serialize anything it will call into the
+/// <see cref="ITransportConfiguration.RequestResponseSerializer"/> implementation of this base class.
+///
+/// <para>e.g: Whenever the <see cref="HttpTransport{TConnectionSettings}"/> receives <see cref="PostData.Serializable{T}"/>
+/// to serialize that data.</para>
+/// </summary>
+public abstract class Serializer
 {
+	// TODO: Overloads taking a Memory<T>/Span<T>??
+
+	/// <summary> Deserialize <paramref name="stream"/> to an instance of <paramref name="type"/> </summary>
+	public abstract object Deserialize(Type type, Stream stream);
+
+	/// <summary> Deserialize <paramref name="stream"/> to an instance of <typeparamref name="T" /></summary>
+	public abstract T Deserialize<T>(Stream stream);
+
+	/// <inheritdoc cref="Deserialize"/>
+	public abstract ValueTask<object> DeserializeAsync(Type type, Stream stream, CancellationToken cancellationToken = default);
+
+	/// <inheritdoc cref="Deserialize"/>
+	public abstract ValueTask<T> DeserializeAsync<T>(Stream stream, CancellationToken cancellationToken = default);
+
 	/// <summary>
-	/// When the <see cref="ITransport{TConnectionSettings}"/> needs to (de)serialize anything it will call into the
-	/// <see cref="ITransportConfiguration.RequestResponseSerializer"/> implementation of this base class.
-	///
-	/// <para>e.g: Whenever the <see cref="ITransport{TConnectionSettings}"/> receives <see cref="PostData.Serializable{T}"/>
-	/// to serialize that data.</para>
+	/// Serialize an instance of <typeparamref name="T"/> to <paramref name="stream"/> using <paramref name="formatting"/>.
 	/// </summary>
-	public abstract class Serializer
-	{
-		// TODO: Overloads taking a Memory<T>/Span<T>??
-
-		/// <summary> Deserialize <paramref name="stream"/> to an instance of <paramref name="type"/> </summary>
-		public abstract object Deserialize(Type type, Stream stream);
-
-		/// <summary> Deserialize <paramref name="stream"/> to an instance of <typeparamref name="T" /></summary>
-		public abstract T Deserialize<T>(Stream stream);
-
-		/// <inheritdoc cref="Deserialize"/>
-		public abstract ValueTask<object> DeserializeAsync(Type type, Stream stream, CancellationToken cancellationToken = default);
-
-		/// <inheritdoc cref="Deserialize"/>
-		public abstract ValueTask<T> DeserializeAsync<T>(Stream stream, CancellationToken cancellationToken = default);
-
-		/// <summary>
-		/// Serialize an instance of <typeparamref name="T"/> to <paramref name="stream"/> using <paramref name="formatting"/>.
-		/// </summary>
-		/// <param name="data">The instance of <typeparamref name="T"/> that we want to serialize.</param>
-		/// <param name="stream">The stream to serialize to.</param>
-		/// <param name="formatting">
-		/// Formatting hint. Note that not all implementations of <see cref="Serializer"/> are able to
-		/// satisfy this hint, including the default serializer that is shipped with 8.0.
-		/// </param>
-		public abstract void Serialize<T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.None);
-
-		/// <inheritdoc cref="Serialize{T}"/>
-		public abstract Task SerializeAsync<T>(
-			T data,
-			Stream stream,
-			SerializationFormatting formatting = SerializationFormatting.None,
-			CancellationToken cancellationToken = default
-		);
-	}
+	/// <param name="data">The instance of <typeparamref name="T"/> that we want to serialize.</param>
+	/// <param name="stream">The stream to serialize to.</param>
+	/// <param name="formatting">
+	/// Formatting hint. Note that not all implementations of <see cref="Serializer"/> are able to
+	/// satisfy this hint, including the default serializer that is shipped with 8.0.
+	/// </param>
+	public abstract void Serialize<T>(T data, Stream stream, SerializationFormatting formatting = SerializationFormatting.None);
+
+	/// <inheritdoc cref="Serialize{T}"/>
+	public abstract Task SerializeAsync<T>(
+		T data,
+		Stream stream,
+		SerializationFormatting formatting = SerializationFormatting.None,
+		CancellationToken cancellationToken = default
+	);
 }
diff --git a/src/Elastic.Transport/Components/Serialization/SerializerRegistrationInformation.cs b/src/Elastic.Transport/Components/Serialization/SerializerRegistrationInformation.cs
index e7ddd99..96fb63d 100644
--- a/src/Elastic.Transport/Components/Serialization/SerializerRegistrationInformation.cs
+++ b/src/Elastic.Transport/Components/Serialization/SerializerRegistrationInformation.cs
@@ -4,34 +4,33 @@
 
 using System;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary> Provides some information to the transport auditing and diagnostics infrastructure about the serializer in use and its <see cref="Purpose"/> </summary>
+public sealed class SerializerRegistrationInformation
 {
-	/// <summary> Provides some information to the transport auditing and diagnostics infrastructure about the serializer in use and its <see cref="Purpose"/> </summary>
-	public sealed class SerializerRegistrationInformation
-	{
-		private readonly string _stringRepresentation;
+	private readonly string _stringRepresentation;
 
-		/// <inheritdoc cref="SerializerRegistrationInformation"/>
-		public SerializerRegistrationInformation(Type type, string purpose)
-		{
-			TypeInformation = type;
-			Purpose = purpose;
-			_stringRepresentation = $"{Purpose}: {TypeInformation.FullName}";
-		}
+	/// <inheritdoc cref="SerializerRegistrationInformation"/>
+	public SerializerRegistrationInformation(Type type, string purpose)
+	{
+		TypeInformation = type;
+		Purpose = purpose;
+		_stringRepresentation = $"{Purpose}: {TypeInformation.FullName}";
+	}
 
-		/// <summary> The type of <see cref="Serializer"/> in use currently </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		public Type TypeInformation { get; }
+	/// <summary> The type of <see cref="Serializer"/> in use currently </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	public Type TypeInformation { get; }
 
-		/// <summary>
-		/// A string describing the purpose of the serializer emitting this events.
-		/// <para>In `Elastisearch.Net` this will always be "request/response"</para>
-		/// <para>Using `Nest` this could also be `source` allowing you to differentiate between the internal and configured source serializer</para>
-		/// </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		public string Purpose { get; }
+	/// <summary>
+	/// A string describing the purpose of the serializer emitting this events.
+	/// <para>In `Elastisearch.Net` this will always be "request/response"</para>
+	/// <para>Using `Nest` this could also be `source` allowing you to differentiate between the internal and configured source serializer</para>
+	/// </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	public string Purpose { get; }
 
-		/// <summary> A precalculated string representation of the serializer in use </summary>
-		public override string ToString() => _stringRepresentation;
-	}
+	/// <summary> A precalculated string representation of the serializer in use </summary>
+	public override string ToString() => _stringRepresentation;
 }
diff --git a/src/Elastic.Transport/Components/Serialization/TransportSerializerExtensions.cs b/src/Elastic.Transport/Components/Serialization/TransportSerializerExtensions.cs
index c78fc3f..d3b215d 100644
--- a/src/Elastic.Transport/Components/Serialization/TransportSerializerExtensions.cs
+++ b/src/Elastic.Transport/Components/Serialization/TransportSerializerExtensions.cs
@@ -2,79 +2,78 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport.Extensions
+namespace Elastic.Transport.Extensions;
+
+/// <summary>
+/// A set of handy extension methods for <see cref="Serializer"/>
+/// </summary>
+public static class TransportSerializerExtensions
 {
 	/// <summary>
-	/// A set of handy extension methods for <see cref="Serializer"/>
+	/// Extension method that serializes an instance of <typeparamref name="T"/> to a byte array.
 	/// </summary>
-	public static class TransportSerializerExtensions
-	{
-		/// <summary>
-		/// Extension method that serializes an instance of <typeparamref name="T"/> to a byte array.
-		/// </summary>
-		public static byte[] SerializeToBytes<T>(
-			this Serializer serializer,
-			T data,
-			SerializationFormatting formatting = SerializationFormatting.None) =>
-			SerializeToBytes(serializer, data, TransportConfiguration.DefaultMemoryStreamFactory, formatting);
+	public static byte[] SerializeToBytes<T>(
+		this Serializer serializer,
+		T data,
+		SerializationFormatting formatting = SerializationFormatting.None) =>
+		SerializeToBytes(serializer, data, TransportConfiguration.DefaultMemoryStreamFactory, formatting);
 
-		/// <summary>
-		/// Extension method that serializes an instance of <typeparamref name="T"/> to a byte array.
-		/// </summary>
-		/// <param name="data"></param>
-		/// <param name="memoryStreamFactory">
-		/// A factory yielding MemoryStream instances, defaults to <see cref="RecyclableMemoryStreamFactory"/>
-		/// that yields memory streams backed by pooled byte arrays.
-		/// </param>
-		/// <param name="serializer"><inheritdoc cref="Serializer" path="/summary"/></param>
-		/// <param name="formatting"><inheritdoc cref="SerializationFormatting" path="/summary"/></param>
-		public static byte[] SerializeToBytes<T>(
-			this Serializer serializer,
-			T data,
-			IMemoryStreamFactory memoryStreamFactory,
-			SerializationFormatting formatting = SerializationFormatting.None
-		)
+	/// <summary>
+	/// Extension method that serializes an instance of <typeparamref name="T"/> to a byte array.
+	/// </summary>
+	/// <param name="data"></param>
+	/// <param name="memoryStreamFactory">
+	/// A factory yielding MemoryStream instances, defaults to <see cref="RecyclableMemoryStreamFactory"/>
+	/// that yields memory streams backed by pooled byte arrays.
+	/// </param>
+	/// <param name="serializer"><inheritdoc cref="Serializer" path="/summary"/></param>
+	/// <param name="formatting"><inheritdoc cref="SerializationFormatting" path="/summary"/></param>
+	public static byte[] SerializeToBytes<T>(
+		this Serializer serializer,
+		T data,
+		MemoryStreamFactory memoryStreamFactory,
+		SerializationFormatting formatting = SerializationFormatting.None
+	)
+	{
+		memoryStreamFactory ??= TransportConfiguration.DefaultMemoryStreamFactory;
+		using (var ms = memoryStreamFactory.Create())
 		{
-			memoryStreamFactory ??= TransportConfiguration.DefaultMemoryStreamFactory;
-			using (var ms = memoryStreamFactory.Create())
-			{
-				serializer.Serialize(data, ms, formatting);
-				return ms.ToArray();
-			}
+			serializer.Serialize(data, ms, formatting);
+			return ms.ToArray();
 		}
+	}
 
-		/// <summary>
-		/// Extension method that serializes an instance of <typeparamref name="T"/> to a string.
-		/// </summary>
-		public static string SerializeToString<T>(
-			this Serializer serializer,
-			T data,
-			SerializationFormatting formatting = SerializationFormatting.None) =>
-			SerializeToString(serializer, data, TransportConfiguration.DefaultMemoryStreamFactory, formatting);
+	/// <summary>
+	/// Extension method that serializes an instance of <typeparamref name="T"/> to a string.
+	/// </summary>
+	public static string SerializeToString<T>(
+		this Serializer serializer,
+		T data,
+		SerializationFormatting formatting = SerializationFormatting.None) =>
+		SerializeToString(serializer, data, TransportConfiguration.DefaultMemoryStreamFactory, formatting);
 
-		/// <summary>
-		/// Extension method that serializes an instance of <typeparamref name="T"/> to a string.
-		/// </summary>
-		/// <param name="data"></param>
-		/// <param name="memoryStreamFactory">
-		/// A factory yielding MemoryStream instances, defaults to <see cref="RecyclableMemoryStreamFactory"/>
-		/// that yields memory streams backed by pooled byte arrays.
-		/// </param>
-		/// <param name="serializer"><inheritdoc cref="Serializer" path="/summary"/></param>
-		/// <param name="formatting"><inheritdoc cref="SerializationFormatting" path="/summary"/></param>
-		public static string SerializeToString<T>(
-			this Serializer serializer,
-			T data,
-			IMemoryStreamFactory memoryStreamFactory,
-			SerializationFormatting formatting = SerializationFormatting.None
-		)
+	/// <summary>
+	/// Extension method that serializes an instance of <typeparamref name="T"/> to a string.
+	/// </summary>
+	/// <param name="data"></param>
+	/// <param name="memoryStreamFactory">
+	/// A factory yielding MemoryStream instances, defaults to <see cref="RecyclableMemoryStreamFactory"/>
+	/// that yields memory streams backed by pooled byte arrays.
+	/// </param>
+	/// <param name="serializer"><inheritdoc cref="Serializer" path="/summary"/></param>
+	/// <param name="formatting"><inheritdoc cref="SerializationFormatting" path="/summary"/></param>
+	public static string SerializeToString<T>(
+		this Serializer serializer,
+		T data,
+		MemoryStreamFactory memoryStreamFactory,
+		SerializationFormatting formatting = SerializationFormatting.None
+	)
+	{
+		memoryStreamFactory ??= TransportConfiguration.DefaultMemoryStreamFactory;
+		using (var ms = memoryStreamFactory.Create())
 		{
-			memoryStreamFactory ??= TransportConfiguration.DefaultMemoryStreamFactory;
-			using (var ms = memoryStreamFactory.Create())
-			{
-				serializer.Serialize(data, ms, formatting);
-				return ms.Utf8String();
-			}
+			serializer.Serialize(data, ms, formatting);
+			return ms.Utf8String();
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Components/TransportClient/CertificateHelpers.cs b/src/Elastic.Transport/Components/TransportClient/CertificateHelpers.cs
index c9c4025..7159937 100644
--- a/src/Elastic.Transport/Components/TransportClient/CertificateHelpers.cs
+++ b/src/Elastic.Transport/Components/TransportClient/CertificateHelpers.cs
@@ -6,47 +6,46 @@
 using System.Security.Cryptography;
 using System.Security.Cryptography.X509Certificates;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+internal static class CertificateHelpers
 {
-	internal static class CertificateHelpers
-	{
-		private const string _colon = ":";
-		private const string _hyphen = "-";
+	private const string _colon = ":";
+	private const string _hyphen = "-";
 
-		/// <summary>
-		/// Returns the result of validating the fingerprint of a certificate against an expected fingerprint string.
-		/// </summary>
-		public static bool ValidateCertificateFingerprint(X509Certificate certificate, string expectedFingerprint)
-		{
-			string sha256Fingerprint;
+	/// <summary>
+	/// Returns the result of validating the fingerprint of a certificate against an expected fingerprint string.
+	/// </summary>
+	public static bool ValidateCertificateFingerprint(X509Certificate certificate, string expectedFingerprint)
+	{
+		string sha256Fingerprint;
 
 #if DOTNETCORE && !NETSTANDARD2_0
-			sha256Fingerprint = certificate.GetCertHashString(HashAlgorithmName.SHA256);
+		sha256Fingerprint = certificate.GetCertHashString(HashAlgorithmName.SHA256);
 #else
-			using var alg = SHA256.Create();
+		using var alg = SHA256.Create();
 
-			var sha256FingerprintBytes = alg.ComputeHash(certificate.GetRawCertData());
-			sha256Fingerprint = BitConverter.ToString(sha256FingerprintBytes);
+		var sha256FingerprintBytes = alg.ComputeHash(certificate.GetRawCertData());
+		sha256Fingerprint = BitConverter.ToString(sha256FingerprintBytes);
 #endif
 
-			sha256Fingerprint = ComparableFingerprint(sha256Fingerprint);
-			return expectedFingerprint.Equals(sha256Fingerprint, StringComparison.OrdinalIgnoreCase);
-		}
-
-		/// <summary>
-		/// Cleans the fingerprint by removing colons and dashes so that a comparison can be made
-		/// without such characters affecting the result.
-		/// </summary>
-		public static string ComparableFingerprint(string fingerprint)
-		{
-			var finalFingerprint = fingerprint;
-
-			if (fingerprint.Contains(_colon))
-				finalFingerprint = fingerprint.Replace(_colon, string.Empty);
-			else if (fingerprint.Contains(_hyphen))
-				finalFingerprint = fingerprint.Replace(_hyphen, string.Empty);
-
-			return finalFingerprint;
-		}
+		sha256Fingerprint = ComparableFingerprint(sha256Fingerprint);
+		return expectedFingerprint.Equals(sha256Fingerprint, StringComparison.OrdinalIgnoreCase);
+	}
+
+	/// <summary>
+	/// Cleans the fingerprint by removing colons and dashes so that a comparison can be made
+	/// without such characters affecting the result.
+	/// </summary>
+	public static string ComparableFingerprint(string fingerprint)
+	{
+		var finalFingerprint = fingerprint;
+
+		if (fingerprint.Contains(_colon))
+			finalFingerprint = fingerprint.Replace(_colon, string.Empty);
+		else if (fingerprint.Contains(_hyphen))
+			finalFingerprint = fingerprint.Replace(_hyphen, string.Empty);
+
+		return finalFingerprint;
 	}
 }
diff --git a/src/Elastic.Transport/Components/TransportClient/CertificateValidations.cs b/src/Elastic.Transport/Components/TransportClient/CertificateValidations.cs
index 47e5fa1..e153046 100644
--- a/src/Elastic.Transport/Components/TransportClient/CertificateValidations.cs
+++ b/src/Elastic.Transport/Components/TransportClient/CertificateValidations.cs
@@ -6,125 +6,124 @@
 using System.Net.Security;
 using System.Security.Cryptography.X509Certificates;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A collection of handy baked in server certificate validation callbacks
+/// </summary>
+public static class CertificateValidations
 {
 	/// <summary>
-	/// A collection of handy baked in server certificate validation callbacks
+	/// DANGEROUS, never use this in production validates ALL certificates to true.
+	/// </summary>
+	/// <returns>Always true, allowing ALL certificates</returns>
+	public static bool AllowAll(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) => true;
+
+	/// <summary>
+	/// Always false, in effect blocking ALL certificates
+	/// </summary>
+	/// <returns>Always false, always blocking ALL certificates</returns>
+	public static bool DenyAll(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) => false;
+
+	/// <summary>
+	/// Helper to create a certificate validation callback based on the certificate authority certificate that we used to
+	/// generate the nodes certificates with. This callback expects the CA to be part of the chain as intermediate CA.
+	/// </summary>
+	/// <param name="caCertificate">The ca certificate used to generate the nodes certificate </param>
+	/// <param name="trustRoot">
+	/// Custom CA are never trusted by default unless they are in the machines trusted store, set this to true
+	/// if you've added the CA to the machines trusted store. In which case UntrustedRoot should not be accepted.
+	/// </param>
+	/// <param name="revocationMode">By default we do not check revocation, it is however recommended to check this (either offline or online).</param>
+	public static Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> AuthorityPartOfChain(
+		X509Certificate caCertificate, bool trustRoot = true, X509RevocationMode revocationMode = X509RevocationMode.NoCheck
+	) =>
+		(sender, cert, chain, errors) =>
+			errors == SslPolicyErrors.None
+			|| ValidIntermediateCa(caCertificate, cert, chain, trustRoot, revocationMode);
+
+	/// <summary>
+	/// Helper to create a certificate validation callback based on the certificate authority certificate that we used to
+	/// generate the nodes certificates with. This callback does NOT expect the CA to be part of the chain presented by the server.
+	/// Including the root certificate in the chain increases the SSL handshake size.
+	/// Elasticsearch's certgen by default does not include the CA in the certificate chain.
 	/// </summary>
-	public static class CertificateValidations
+	/// <param name="caCertificate">The ca certificate used to generate the nodes certificate </param>
+	/// <param name="trustRoot">
+	/// Custom CA are never trusted by default unless they are in the machines trusted store, set this to true
+	/// if you've added the CA to the machines trusted store. In which case UntrustedRoot should not be accepted.
+	/// </param>
+	/// <param name="revocationMode">By default we do not check revocation, it is however recommended to check this (either offline or online).</param>
+	public static Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> AuthorityIsRoot(
+		X509Certificate caCertificate, bool trustRoot = true, X509RevocationMode revocationMode = X509RevocationMode.NoCheck
+	) =>
+		(sender, cert, chain, errors) =>
+			errors == SslPolicyErrors.None
+			|| ValidRootCa(caCertificate, cert, trustRoot, revocationMode);
+
+	private static bool ValidRootCa(X509Certificate caCertificate, X509Certificate certificate, bool trustRoot,
+		X509RevocationMode revocationMode
+	)
 	{
-		/// <summary>
-		/// DANGEROUS, never use this in production validates ALL certificates to true.
-		/// </summary>
-		/// <returns>Always true, allowing ALL certificates</returns>
-		public static bool AllowAll(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) => true;
-
-		/// <summary>
-		/// Always false, in effect blocking ALL certificates
-		/// </summary>
-		/// <returns>Always false, always blocking ALL certificates</returns>
-		public static bool DenyAll(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) => false;
-
-		/// <summary>
-		/// Helper to create a certificate validation callback based on the certificate authority certificate that we used to
-		/// generate the nodes certificates with. This callback expects the CA to be part of the chain as intermediate CA.
-		/// </summary>
-		/// <param name="caCertificate">The ca certificate used to generate the nodes certificate </param>
-		/// <param name="trustRoot">
-		/// Custom CA are never trusted by default unless they are in the machines trusted store, set this to true
-		/// if you've added the CA to the machines trusted store. In which case UntrustedRoot should not be accepted.
-		/// </param>
-		/// <param name="revocationMode">By default we do not check revocation, it is however recommended to check this (either offline or online).</param>
-		public static Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> AuthorityPartOfChain(
-			X509Certificate caCertificate, bool trustRoot = true, X509RevocationMode revocationMode = X509RevocationMode.NoCheck
-		) =>
-			(sender, cert, chain, errors) =>
-				errors == SslPolicyErrors.None
-				|| ValidIntermediateCa(caCertificate, cert, chain, trustRoot, revocationMode);
-
-		/// <summary>
-		/// Helper to create a certificate validation callback based on the certificate authority certificate that we used to
-		/// generate the nodes certificates with. This callback does NOT expect the CA to be part of the chain presented by the server.
-		/// Including the root certificate in the chain increases the SSL handshake size.
-		/// Elasticsearch's certgen by default does not include the CA in the certificate chain.
-		/// </summary>
-		/// <param name="caCertificate">The ca certificate used to generate the nodes certificate </param>
-		/// <param name="trustRoot">
-		/// Custom CA are never trusted by default unless they are in the machines trusted store, set this to true
-		/// if you've added the CA to the machines trusted store. In which case UntrustedRoot should not be accepted.
-		/// </param>
-		/// <param name="revocationMode">By default we do not check revocation, it is however recommended to check this (either offline or online).</param>
-		public static Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> AuthorityIsRoot(
-			X509Certificate caCertificate, bool trustRoot = true, X509RevocationMode revocationMode = X509RevocationMode.NoCheck
-		) =>
-			(sender, cert, chain, errors) =>
-				errors == SslPolicyErrors.None
-				|| ValidRootCa(caCertificate, cert, trustRoot, revocationMode);
-
-		private static bool ValidRootCa(X509Certificate caCertificate, X509Certificate certificate, bool trustRoot,
-			X509RevocationMode revocationMode
-		)
+		var ca = new X509Certificate2(caCertificate);
+		var privateChain = new X509Chain { ChainPolicy = { RevocationMode = revocationMode } };
+		privateChain.ChainPolicy.ExtraStore.Add(ca);
+		privateChain.Build(new X509Certificate2(certificate));
+
+		//lets validate the our chain status
+		foreach (var chainStatus in privateChain.ChainStatus)
 		{
-			var ca = new X509Certificate2(caCertificate);
-			var privateChain = new X509Chain { ChainPolicy = { RevocationMode = revocationMode } };
-			privateChain.ChainPolicy.ExtraStore.Add(ca);
-			privateChain.Build(new X509Certificate2(certificate));
-
-			//lets validate the our chain status
-			foreach (var chainStatus in privateChain.ChainStatus)
-			{
-				//custom CA's that are not in the machine trusted store will always have this status
-				//by setting trustRoot = true (default) we skip this error
-				if (chainStatus.Status == X509ChainStatusFlags.UntrustedRoot && trustRoot) continue;
-
-				//trustRoot is false so we expected our CA to be in the machines trusted store
-				if (chainStatus.Status == X509ChainStatusFlags.UntrustedRoot) return false;
-
-				//otherwise if the chain has any error of any sort return false
-				if (chainStatus.Status != X509ChainStatusFlags.NoError) return false;
-			}
-			return true;
+			//custom CA's that are not in the machine trusted store will always have this status
+			//by setting trustRoot = true (default) we skip this error
+			if (chainStatus.Status == X509ChainStatusFlags.UntrustedRoot && trustRoot) continue;
+
+			//trustRoot is false so we expected our CA to be in the machines trusted store
+			if (chainStatus.Status == X509ChainStatusFlags.UntrustedRoot) return false;
+
+			//otherwise if the chain has any error of any sort return false
+			if (chainStatus.Status != X509ChainStatusFlags.NoError) return false;
 		}
+		return true;
+	}
+
+	private static bool ValidIntermediateCa(X509Certificate caCertificate, X509Certificate certificate, X509Chain chain, bool trustRoot,
+		X509RevocationMode revocationMode
+	)
+	{
+		var ca = new X509Certificate2(caCertificate);
+		var privateChain = new X509Chain { ChainPolicy = { RevocationMode = revocationMode } };
+		privateChain.ChainPolicy.ExtraStore.Add(ca);
+		privateChain.Build(new X509Certificate2(certificate));
+
+		//Assert our chain has the same number of elements as the certifcate presented by the server
+		if (chain.ChainElements.Count != privateChain.ChainElements.Count) return false;
 
-		private static bool ValidIntermediateCa(X509Certificate caCertificate, X509Certificate certificate, X509Chain chain, bool trustRoot,
-			X509RevocationMode revocationMode
-		)
+		//lets validate the our chain status
+		foreach (var chainStatus in privateChain.ChainStatus)
 		{
-			var ca = new X509Certificate2(caCertificate);
-			var privateChain = new X509Chain { ChainPolicy = { RevocationMode = revocationMode } };
-			privateChain.ChainPolicy.ExtraStore.Add(ca);
-			privateChain.Build(new X509Certificate2(certificate));
-
-			//Assert our chain has the same number of elements as the certifcate presented by the server
-			if (chain.ChainElements.Count != privateChain.ChainElements.Count) return false;
-
-			//lets validate the our chain status
-			foreach (var chainStatus in privateChain.ChainStatus)
-			{
-				//custom CA's that are not in the machine trusted store will always have this status
-				//by setting trustRoot = true (default) we skip this error
-				if (chainStatus.Status == X509ChainStatusFlags.UntrustedRoot && trustRoot) continue;
-
-				//trustRoot is false so we expected our CA to be in the machines trusted store
-				if (chainStatus.Status == X509ChainStatusFlags.UntrustedRoot) return false;
-
-				//otherwise if the chain has any error of any sort return false
-				if (chainStatus.Status != X509ChainStatusFlags.NoError) return false;
-			}
-
-			var found = false;
-			//We are going to walk both chains and make sure the thumbprints align
-			//while making sure one of the chains certificates presented by the server has our expected CA thumbprint
-			for (var i = 0; i < chain.ChainElements.Count; i++)
-			{
-				var c = chain.ChainElements[i].Certificate.Thumbprint;
-				var cPrivate = privateChain.ChainElements[i].Certificate.Thumbprint;
-				if (!found && c == ca.Thumbprint) found = true;
-
-				//mis aligned certificate chain, return false so we do not accept this certificate
-				if (c != cPrivate) return false;
-			}
-			return found;
+			//custom CA's that are not in the machine trusted store will always have this status
+			//by setting trustRoot = true (default) we skip this error
+			if (chainStatus.Status == X509ChainStatusFlags.UntrustedRoot && trustRoot) continue;
+
+			//trustRoot is false so we expected our CA to be in the machines trusted store
+			if (chainStatus.Status == X509ChainStatusFlags.UntrustedRoot) return false;
+
+			//otherwise if the chain has any error of any sort return false
+			if (chainStatus.Status != X509ChainStatusFlags.NoError) return false;
+		}
+
+		var found = false;
+		//We are going to walk both chains and make sure the thumbprints align
+		//while making sure one of the chains certificates presented by the server has our expected CA thumbprint
+		for (var i = 0; i < chain.ChainElements.Count; i++)
+		{
+			var c = chain.ChainElements[i].Certificate.Thumbprint;
+			var cPrivate = privateChain.ChainElements[i].Certificate.Thumbprint;
+			if (!found && c == ca.Thumbprint) found = true;
+
+			//mis aligned certificate chain, return false so we do not accept this certificate
+			if (c != cPrivate) return false;
 		}
+		return found;
 	}
 }
diff --git a/src/Elastic.Transport/Components/TransportClient/Content/RequestDataContent.cs b/src/Elastic.Transport/Components/TransportClient/Content/RequestDataContent.cs
index bdee4f6..7631c33 100644
--- a/src/Elastic.Transport/Components/TransportClient/Content/RequestDataContent.cs
+++ b/src/Elastic.Transport/Components/TransportClient/Content/RequestDataContent.cs
@@ -19,212 +19,214 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Provides an <see cref="HttpContent"/> implementation that exposes an output <see cref="Stream"/>
+/// which can be written to directly. The ability to push data to the output stream differs from the
+/// <see cref="StreamContent"/> where data is pulled and not pushed.
+/// </summary>
+internal sealed class RequestDataContent : HttpContent
 {
-	/// <summary>
-	/// Provides an <see cref="HttpContent"/> implementation that exposes an output <see cref="Stream"/>
-	/// which can be written to directly. The ability to push data to the output stream differs from the
-	/// <see cref="StreamContent"/> where data is pulled and not pushed.
-	/// </summary>
-	internal class RequestDataContent : HttpContent
-	{
-		private readonly RequestData _requestData;
+	private readonly RequestData _requestData;
 
-		private readonly Func<RequestData, CompleteTaskOnCloseStream, RequestDataContent, TransportContext, CancellationToken, Task>
-			_onStreamAvailableAsync;
+	private readonly Func<RequestData, CompleteTaskOnCloseStream, RequestDataContent, TransportContext, CancellationToken, Task>
+		_onStreamAvailableAsync;
 
-		private readonly Action<RequestData, CompleteTaskOnCloseStream, RequestDataContent, TransportContext> _onStreamAvailable;
-		private readonly CancellationToken _token;
+	private readonly Action<RequestData, CompleteTaskOnCloseStream, RequestDataContent, TransportContext> _onStreamAvailable;
+	private readonly CancellationToken _token;
 
-		/// <summary> Constructor used in synchronous paths. </summary>
-		public RequestDataContent(RequestData requestData)
-		{
-			_requestData = requestData;
-			_token = default;
-			Headers.ContentType = new MediaTypeHeaderValue(requestData.RequestMimeType);
-			if (requestData.HttpCompression)
-				Headers.ContentEncoding.Add("gzip");
-
-			_onStreamAvailable = OnStreamAvailable;
-			_onStreamAvailableAsync = OnStreamAvailableAsync;
-		}
+	/// <summary> Constructor used in synchronous paths. </summary>
+	public RequestDataContent(RequestData requestData)
+	{
+		_requestData = requestData;
+		_token = default;
+		Headers.ContentType = new MediaTypeHeaderValue(requestData.RequestMimeType);
+		if (requestData.HttpCompression)
+			Headers.ContentEncoding.Add("gzip");
+
+		_onStreamAvailable = OnStreamAvailable;
+		_onStreamAvailableAsync = OnStreamAvailableAsync;
+	}
 
-		private static void OnStreamAvailable(RequestData data, Stream stream, HttpContent content, TransportContext context)
-		{
-			if (data.HttpCompression) stream = new GZipStream(stream, CompressionMode.Compress, false);
+	private static void OnStreamAvailable(RequestData data, Stream stream, HttpContent content, TransportContext context)
+	{
+		if (data.HttpCompression) stream = new GZipStream(stream, CompressionMode.Compress, false);
 
-			using (stream) data.PostData.Write(stream, data.ConnectionSettings);
-		}
+		using (stream) data.PostData.Write(stream, data.ConnectionSettings);
+	}
 
-		/// <summary> Constructor used in asynchronous paths. </summary>
-		public RequestDataContent(RequestData requestData, CancellationToken token)
-		{
-			_requestData = requestData;
-			_token = token;
-			Headers.ContentType = new MediaTypeHeaderValue(requestData.RequestMimeType);
-			if (requestData.HttpCompression)
-				Headers.ContentEncoding.Add("gzip");
-
-			_onStreamAvailable = OnStreamAvailable;
-			_onStreamAvailableAsync = OnStreamAvailableAsync;
-		}
+	/// <summary> Constructor used in asynchronous paths. </summary>
+	public RequestDataContent(RequestData requestData, CancellationToken token)
+	{
+		_requestData = requestData;
+		_token = token;
+		Headers.ContentType = new MediaTypeHeaderValue(requestData.RequestMimeType);
+		if (requestData.HttpCompression)
+			Headers.ContentEncoding.Add("gzip");
+
+		_onStreamAvailable = OnStreamAvailable;
+		_onStreamAvailableAsync = OnStreamAvailableAsync;
+	}
 
-		private static async Task OnStreamAvailableAsync(RequestData data, Stream stream, HttpContent content, TransportContext context, CancellationToken ctx = default)
-		{
-			if (data.HttpCompression) stream = new GZipStream(stream, CompressionMode.Compress, false);
+	private static async Task OnStreamAvailableAsync(RequestData data, Stream stream, HttpContent content, TransportContext context, CancellationToken ctx = default)
+	{
+		if (data.HttpCompression) stream = new GZipStream(stream, CompressionMode.Compress, false);
 
 #if NET5_0_OR_GREATER
-			await
+		await using (stream.ConfigureAwait(false))
+#else
+		using (stream)
 #endif
-				using (stream)
-				await data.PostData.WriteAsync(stream, data.ConnectionSettings, ctx).ConfigureAwait(false);
-		}
+		await data.PostData.WriteAsync(stream, data.ConnectionSettings, ctx).ConfigureAwait(false);
+	}
+
+	/// <summary>
+	/// When this method is called, it calls the action provided in the constructor with the output
+	/// stream to write to. Once the action has completed its work it closes the stream which will
+	/// close this content instance and complete the HTTP request or response.
+	/// </summary>
+	/// <param name="stream">The <see cref="Stream"/> to which to write.</param>
+	/// <param name="context">The associated <see cref="TransportContext"/>.</param>
+	/// <returns>A <see cref="Task"/> instance that is asynchronously serializing the object's content.</returns>
+	[SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is passed as task result.")]
+	protected override Task SerializeToStreamAsync(Stream stream, TransportContext context) =>
+		SerializeToStreamAsync(stream, context, default);
+
 
-		/// <summary>
-		/// When this method is called, it calls the action provided in the constructor with the output
-		/// stream to write to. Once the action has completed its work it closes the stream which will
-		/// close this content instance and complete the HTTP request or response.
-		/// </summary>
-		/// <param name="stream">The <see cref="Stream"/> to which to write.</param>
-		/// <param name="context">The associated <see cref="TransportContext"/>.</param>
-		/// <returns>A <see cref="Task"/> instance that is asynchronously serializing the object's content.</returns>
-		[SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is passed as task result.")]
-		protected override Task SerializeToStreamAsync(Stream stream, TransportContext context) =>
-			SerializeToStreamAsync(stream, context, default);
-
-		protected
 #if NET5_0_OR_GREATER
-			override
+	protected override
+#else
+	private
 #endif
-			async Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken)
-		{
-			var source = CancellationTokenSource.CreateLinkedTokenSource(_token, cancellationToken);
-			var serializeToStreamTask = new TaskCompletionSource<bool>();
-			var wrappedStream = new CompleteTaskOnCloseStream(stream, serializeToStreamTask);
-			await _onStreamAvailableAsync(_requestData, wrappedStream, this, context, source.Token).ConfigureAwait(false);
-			await serializeToStreamTask.Task.ConfigureAwait(false);
-		}
+		async Task SerializeToStreamAsync(Stream stream, TransportContext context, CancellationToken cancellationToken)
+	{
+		var source = CancellationTokenSource.CreateLinkedTokenSource(_token, cancellationToken);
+		var serializeToStreamTask = new TaskCompletionSource<bool>();
+		var wrappedStream = new CompleteTaskOnCloseStream(stream, serializeToStreamTask);
+		await _onStreamAvailableAsync(_requestData, wrappedStream, this, context, source.Token).ConfigureAwait(false);
+		await serializeToStreamTask.Task.ConfigureAwait(false);
+	}
 
 #if NET5_0_OR_GREATER
-		protected override void SerializeToStream(Stream stream, TransportContext context, CancellationToken _)
-		{
-			var serializeToStreamTask = new TaskCompletionSource<bool>();
-			using var wrappedStream = new CompleteTaskOnCloseStream(stream, serializeToStreamTask);
-			_onStreamAvailable(_requestData, wrappedStream, this, context);
-			//await serializeToStreamTask.Task.ConfigureAwait(false);
-		}
+	protected override void SerializeToStream(Stream stream, TransportContext context, CancellationToken _)
+	{
+		var serializeToStreamTask = new TaskCompletionSource<bool>();
+		using var wrappedStream = new CompleteTaskOnCloseStream(stream, serializeToStreamTask);
+		_onStreamAvailable(_requestData, wrappedStream, this, context);
+		//await serializeToStreamTask.Task.ConfigureAwait(false);
+	}
 #endif
 
-		/// <summary>
-		/// Computes the length of the stream if possible.
-		/// </summary>
-		/// <param name="length">The computed length of the stream.</param>
-		/// <returns><c>true</c> if the length has been computed; otherwise <c>false</c>.</returns>
-		protected override bool TryComputeLength(out long length)
+	/// <summary>
+	/// Computes the length of the stream if possible.
+	/// </summary>
+	/// <param name="length">The computed length of the stream.</param>
+	/// <returns><c>true</c> if the length has been computed; otherwise <c>false</c>.</returns>
+	protected override bool TryComputeLength(out long length)
+	{
+		// We can't know the length of the content being pushed to the output stream.
+		length = -1;
+		return false;
+	}
+
+	internal class CompleteTaskOnCloseStream : DelegatingStream
+	{
+		private readonly TaskCompletionSource<bool> _serializeToStreamTask;
+
+		public CompleteTaskOnCloseStream(Stream innerStream, TaskCompletionSource<bool> serializeToStreamTask)
+			: base(innerStream)
 		{
-			// We can't know the length of the content being pushed to the output stream.
-			length = -1;
-			return false;
+			Contract.Assert(serializeToStreamTask != null);
+			_serializeToStreamTask = serializeToStreamTask;
 		}
 
-		internal class CompleteTaskOnCloseStream : DelegatingStream
+		protected override void Dispose(bool disposing)
 		{
-			private readonly TaskCompletionSource<bool> _serializeToStreamTask;
-
-			public CompleteTaskOnCloseStream(Stream innerStream, TaskCompletionSource<bool> serializeToStreamTask)
-				: base(innerStream)
-			{
-				Contract.Assert(serializeToStreamTask != null);
-				_serializeToStreamTask = serializeToStreamTask;
-			}
-
-			protected override void Dispose(bool disposing)
-			{
-				_serializeToStreamTask.TrySetResult(true);
-				base.Dispose();
-			}
-
-			public override void Close() => _serializeToStreamTask.TrySetResult(true);
+			_serializeToStreamTask.TrySetResult(true);
+			base.Dispose();
 		}
 
-		/// <summary>
-		/// Stream that delegates to inner stream.
-		/// This is taken from System.Net.Http
-		/// </summary>
-		internal abstract class DelegatingStream : Stream
-		{
-			private readonly Stream _innerStream;
+		public override void Close() => _serializeToStreamTask.TrySetResult(true);
+	}
 
-			protected DelegatingStream(Stream innerStream) => _innerStream = innerStream ?? throw new ArgumentNullException(nameof(innerStream));
+	/// <summary>
+	/// Stream that delegates to inner stream.
+	/// This is taken from System.Net.Http
+	/// </summary>
+	internal abstract class DelegatingStream : Stream
+	{
+		private readonly Stream _innerStream;
 
-			public override bool CanRead => _innerStream.CanRead;
+		protected DelegatingStream(Stream innerStream) => _innerStream = innerStream ?? throw new ArgumentNullException(nameof(innerStream));
 
-			public override bool CanSeek => _innerStream.CanSeek;
+		public override bool CanRead => _innerStream.CanRead;
 
-			public override bool CanWrite => _innerStream.CanWrite;
+		public override bool CanSeek => _innerStream.CanSeek;
 
-			public override long Length => _innerStream.Length;
+		public override bool CanWrite => _innerStream.CanWrite;
 
-			public override long Position
-			{
-				get => _innerStream.Position;
-				set => _innerStream.Position = value;
-			}
+		public override long Length => _innerStream.Length;
 
-			public override int ReadTimeout
-			{
-				get => _innerStream.ReadTimeout;
-				set => _innerStream.ReadTimeout = value;
-			}
+		public override long Position
+		{
+			get => _innerStream.Position;
+			set => _innerStream.Position = value;
+		}
 
-			public override bool CanTimeout => _innerStream.CanTimeout;
+		public override int ReadTimeout
+		{
+			get => _innerStream.ReadTimeout;
+			set => _innerStream.ReadTimeout = value;
+		}
 
-			public override int WriteTimeout
-			{
-				get => _innerStream.WriteTimeout;
-				set => _innerStream.WriteTimeout = value;
-			}
+		public override bool CanTimeout => _innerStream.CanTimeout;
 
-			protected override void Dispose(bool disposing)
-			{
-				if (disposing) _innerStream.Dispose();
-				base.Dispose(disposing);
-			}
+		public override int WriteTimeout
+		{
+			get => _innerStream.WriteTimeout;
+			set => _innerStream.WriteTimeout = value;
+		}
+
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing) _innerStream.Dispose();
+			base.Dispose(disposing);
+		}
 
-			public override long Seek(long offset, SeekOrigin origin) => _innerStream.Seek(offset, origin);
+		public override long Seek(long offset, SeekOrigin origin) => _innerStream.Seek(offset, origin);
 
-			public override int Read(byte[] buffer, int offset, int count) => _innerStream.Read(buffer, offset, count);
+		public override int Read(byte[] buffer, int offset, int count) => _innerStream.Read(buffer, offset, count);
 
-			public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
-				_innerStream.ReadAsync(buffer, offset, count, cancellationToken);
+		public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
+			_innerStream.ReadAsync(buffer, offset, count, cancellationToken);
 
-			public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state) =>
-				_innerStream.BeginRead(buffer, offset, count, callback, state);
+		public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state) =>
+			_innerStream.BeginRead(buffer, offset, count, callback, state);
 
-			public override int EndRead(IAsyncResult asyncResult) => _innerStream.EndRead(asyncResult);
+		public override int EndRead(IAsyncResult asyncResult) => _innerStream.EndRead(asyncResult);
 
-			public override int ReadByte() => _innerStream.ReadByte();
+		public override int ReadByte() => _innerStream.ReadByte();
 
-			public override void Flush() => _innerStream.Flush();
+		public override void Flush() => _innerStream.Flush();
 
-			public override Task FlushAsync(CancellationToken cancellationToken) => _innerStream.FlushAsync(cancellationToken);
+		public override Task FlushAsync(CancellationToken cancellationToken) => _innerStream.FlushAsync(cancellationToken);
 
-			public override void SetLength(long value) => _innerStream.SetLength(value);
+		public override void SetLength(long value) => _innerStream.SetLength(value);
 
-			public override void Write(byte[] buffer, int offset, int count) => _innerStream.Write(buffer, offset, count);
+		public override void Write(byte[] buffer, int offset, int count) => _innerStream.Write(buffer, offset, count);
 
-			public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
-				_innerStream.WriteAsync(buffer, offset, count, cancellationToken);
+		public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) =>
+			_innerStream.WriteAsync(buffer, offset, count, cancellationToken);
 
-			public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state) =>
-				_innerStream.BeginWrite(buffer, offset, count, callback, state);
+		public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state) =>
+			_innerStream.BeginWrite(buffer, offset, count, callback, state);
 
-			public override void EndWrite(IAsyncResult asyncResult) => _innerStream.EndWrite(asyncResult);
+		public override void EndWrite(IAsyncResult asyncResult) => _innerStream.EndWrite(asyncResult);
 
-			public override void WriteByte(byte value) => _innerStream.WriteByte(value);
+		public override void WriteByte(byte value) => _innerStream.WriteByte(value);
 
-			public override void Close() => _innerStream.Close();
-		}
+		public override void Close() => _innerStream.Close();
 	}
 }
 #endif
diff --git a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ActiveHandlerTrackingEntry.cs b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ActiveHandlerTrackingEntry.cs
index 5a24f7f..5fe81e8 100644
--- a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ActiveHandlerTrackingEntry.cs
+++ b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ActiveHandlerTrackingEntry.cs
@@ -11,14 +11,14 @@
 using System.Diagnostics;
 using System.Threading;
 
-namespace Elastic.Transport
-{
-	/// <summary>
+namespace Elastic.Transport;
+
+/// <summary>
     /// Thread-safety: We treat this class as immutable except for the timer. Creating a new object
-	/// for the 'expiry' pool simplifies the threading requirements significantly.
-	/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/ActiveHandlerTrackingEntry.cs</para>
-	/// </summary>
-    internal class ActiveHandlerTrackingEntry
+/// for the 'expiry' pool simplifies the threading requirements significantly.
+/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/ActiveHandlerTrackingEntry.cs</para>
+/// </summary>
+    internal sealed class ActiveHandlerTrackingEntry
     {
         private static readonly TimerCallback TimerCallback = (s) => ((ActiveHandlerTrackingEntry)s).Timer_Tick();
         private readonly object _lock;
@@ -74,15 +74,14 @@ private void Timer_Tick()
             Debug.Assert(_timer != null);
 
             lock (_lock)
-			{
-				if (_timer == null) return;
+		{
+			if (_timer == null) return;
 
-				_timer.Dispose();
-				_timer = null;
+			_timer.Dispose();
+			_timer = null;
 
-				_callback(this);
-			}
+			_callback(this);
+		}
         }
     }
-}
 #endif
diff --git a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ExpiredHandlerTrackingEntry.cs b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ExpiredHandlerTrackingEntry.cs
index 52cea00..eaf8569 100644
--- a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ExpiredHandlerTrackingEntry.cs
+++ b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ExpiredHandlerTrackingEntry.cs
@@ -10,31 +10,30 @@
 using System;
 using System.Net.Http;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Thread-safety: This class is immutable
+/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/ExpiredHandlerTrackingEntry.cs</para>
+/// </summary>
+internal sealed class ExpiredHandlerTrackingEntry
 {
-	/// <summary>
-	/// Thread-safety: This class is immutable
-	/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/ExpiredHandlerTrackingEntry.cs</para>
-	/// </summary>
-	internal class ExpiredHandlerTrackingEntry
-	{
-		private readonly WeakReference _livenessTracker;
+	private readonly WeakReference _livenessTracker;
 
-		// IMPORTANT: don't cache a reference to `other` or `other.Handler` here.
-		// We need to allow it to be GC'ed.
-		public ExpiredHandlerTrackingEntry(ActiveHandlerTrackingEntry other)
-		{
-			Key = other.Key;
+	// IMPORTANT: don't cache a reference to `other` or `other.Handler` here.
+	// We need to allow it to be GC'ed.
+	public ExpiredHandlerTrackingEntry(ActiveHandlerTrackingEntry other)
+	{
+		Key = other.Key;
 
-			_livenessTracker = new WeakReference(other.Handler);
-			InnerHandler = other.Handler.InnerHandler;
-		}
+		_livenessTracker = new WeakReference(other.Handler);
+		InnerHandler = other.Handler.InnerHandler;
+	}
 
-		public bool CanDispose => !_livenessTracker.IsAlive;
+	public bool CanDispose => !_livenessTracker.IsAlive;
 
-		public HttpMessageHandler InnerHandler { get; }
+	public HttpMessageHandler InnerHandler { get; }
 
-		public int Key { get; }
-	}
+	public int Key { get; }
 }
 #endif
diff --git a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/LifetimeTrackingHttpMessageHandler.cs b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/LifetimeTrackingHttpMessageHandler.cs
index 85a0f6e..cd3572e 100644
--- a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/LifetimeTrackingHttpMessageHandler.cs
+++ b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/LifetimeTrackingHttpMessageHandler.cs
@@ -9,23 +9,22 @@
 #if DOTNETCORE
 using System.Net.Http;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// This a marker used to check if the underlying handler should be disposed. HttpClients
+/// share a reference to an instance of this class, and when it goes out of scope the inner handler
+/// is eligible to be disposed.
+/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/LifetimeTrackingHttpMessageHandler.cs</para>
+/// </summary>
+internal sealed class LifetimeTrackingHttpMessageHandler : DelegatingHandler
 {
-	/// <summary>
-	/// This a marker used to check if the underlying handler should be disposed. HttpClients
-	/// share a reference to an instance of this class, and when it goes out of scope the inner handler
-	/// is eligible to be disposed.
-	/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/LifetimeTrackingHttpMessageHandler.cs</para>
-	/// </summary>
-	internal class LifetimeTrackingHttpMessageHandler : DelegatingHandler
-	{
-		public LifetimeTrackingHttpMessageHandler(HttpMessageHandler innerHandler)
-			: base(innerHandler) { }
+	public LifetimeTrackingHttpMessageHandler(HttpMessageHandler innerHandler)
+		: base(innerHandler) { }
 
-		protected override void Dispose(bool disposing)
-		{
-			// The lifetime of this is tracked separately by ActiveHandlerTrackingEntry
-		}
+	protected override void Dispose(bool disposing)
+	{
+		// The lifetime of this is tracked separately by ActiveHandlerTrackingEntry
 	}
 }
 #endif
diff --git a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/RequestDataHttpClientFactory.cs b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/RequestDataHttpClientFactory.cs
index f10dc38..33e6da6 100644
--- a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/RequestDataHttpClientFactory.cs
+++ b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/RequestDataHttpClientFactory.cs
@@ -13,254 +13,253 @@
 using System.Net.Http;
 using System.Threading;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Heavily modified version of DefaultHttpClientFactory, re-purposed for RequestData
+/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/DefaultHttpClientFactory.cs</para>
+/// </summary>
+internal sealed class RequestDataHttpClientFactory : IDisposable
 {
+	private readonly Func<RequestData, HttpMessageHandler> _createHttpClientHandler;
+	private static readonly TimerCallback CleanupCallback = (s) => ((RequestDataHttpClientFactory)s).CleanupTimer_Tick();
+	private readonly Func<int, RequestData, Lazy<ActiveHandlerTrackingEntry>> _entryFactory;
+
+	// Default time of 10s for cleanup seems reasonable.
+	// Quick math:
+	// 10 distinct named clients * expiry time >= 1s = approximate cleanup queue of 100 items
+	//
+	// This seems frequent enough. We also rely on GC occurring to actually trigger disposal.
+	private readonly TimeSpan _defaultCleanupInterval = TimeSpan.FromSeconds(10);
+
+	// We use a new timer for each regular cleanup cycle, protected with a lock. Note that this scheme
+	// doesn't give us anything to dispose, as the timer is started/stopped as needed.
+	//
+	// There's no need for the factory itself to be disposable. If you stop using it, eventually everything will
+	// get reclaimed.
+	private Timer _cleanupTimer;
+	private readonly object _cleanupTimerLock;
+	private readonly object _cleanupActiveLock;
+
+	// Collection of 'active' handlers.
+	//
+	// Using lazy for synchronization to ensure that only one instance of HttpMessageHandler is created
+	// for each name.
+	//
+	private readonly ConcurrentDictionary<int, Lazy<ActiveHandlerTrackingEntry>> _activeHandlers;
+
 	/// <summary>
-	/// Heavily modified version of DefaultHttpClientFactory, re-purposed for RequestData
-	/// <para>https://github.com/dotnet/runtime/blob/master/src/libraries/Microsoft.Extensions.Http/src/DefaultHttpClientFactory.cs</para>
+	/// The total number if in use message handlers, this number should not exceed the double digits
+	/// for any default setup
 	/// </summary>
-	internal class RequestDataHttpClientFactory : IDisposable
-	{
-		private readonly Func<RequestData, HttpMessageHandler> _createHttpClientHandler;
-		private static readonly TimerCallback CleanupCallback = (s) => ((RequestDataHttpClientFactory)s).CleanupTimer_Tick();
-		private readonly Func<int, RequestData, Lazy<ActiveHandlerTrackingEntry>> _entryFactory;
+	public int InUseHandlers => _activeHandlers.Count;
 
-		// Default time of 10s for cleanup seems reasonable.
-		// Quick math:
-		// 10 distinct named clients * expiry time >= 1s = approximate cleanup queue of 100 items
-		//
-		// This seems frequent enough. We also rely on GC occurring to actually trigger disposal.
-		private readonly TimeSpan _defaultCleanupInterval = TimeSpan.FromSeconds(10);
-
-		// We use a new timer for each regular cleanup cycle, protected with a lock. Note that this scheme
-		// doesn't give us anything to dispose, as the timer is started/stopped as needed.
-		//
-		// There's no need for the factory itself to be disposable. If you stop using it, eventually everything will
-		// get reclaimed.
-		private Timer _cleanupTimer;
-		private readonly object _cleanupTimerLock;
-		private readonly object _cleanupActiveLock;
+	private int _removedHandlers;
+	/// <summary>
+	/// The total amount of handlers that have been swapped over during the lifetime of the application.
+	/// This can be high depending on how aggressive the DNS caching is setup.
+	/// </summary>
+	public int RemovedHandlers => _removedHandlers;
 
-		// Collection of 'active' handlers.
-		//
-		// Using lazy for synchronization to ensure that only one instance of HttpMessageHandler is created
-		// for each name.
-		//
-		private readonly ConcurrentDictionary<int, Lazy<ActiveHandlerTrackingEntry>> _activeHandlers;
-
-		/// <summary>
-		/// The total number if in use message handlers, this number should not exceed the double digits
-		/// for any default setup
-		/// </summary>
-		public int InUseHandlers => _activeHandlers.Count;
-
-		private int _removedHandlers;
-		/// <summary>
-		/// The total amount of handlers that have been swapped over during the lifetime of the application.
-		/// This can be high depending on how aggressive the DNS caching is setup.
-		/// </summary>
-		public int RemovedHandlers => _removedHandlers;
-
-		// Collection of 'expired' but not yet disposed handlers.
-		//
-		// Used when we're rotating handlers so that we can dispose HttpMessageHandler instances once they
-		// are eligible for garbage collection.
-		//
-		private readonly ConcurrentQueue<ExpiredHandlerTrackingEntry> _expiredHandlers;
-		private readonly TimerCallback _expiryCallback;
+	// Collection of 'expired' but not yet disposed handlers.
+	//
+	// Used when we're rotating handlers so that we can dispose HttpMessageHandler instances once they
+	// are eligible for garbage collection.
+	//
+	private readonly ConcurrentQueue<ExpiredHandlerTrackingEntry> _expiredHandlers;
+	private readonly TimerCallback _expiryCallback;
 
-		public RequestDataHttpClientFactory(Func<RequestData, HttpMessageHandler> createHttpClientHandler)
+	public RequestDataHttpClientFactory(Func<RequestData, HttpMessageHandler> createHttpClientHandler)
+	{
+		_createHttpClientHandler = createHttpClientHandler;
+		// case-sensitive because named options is.
+		_activeHandlers = new ConcurrentDictionary<int, Lazy<ActiveHandlerTrackingEntry>>();
+		_entryFactory = (key, requestData) =>
 		{
-			_createHttpClientHandler = createHttpClientHandler;
-			// case-sensitive because named options is.
-			_activeHandlers = new ConcurrentDictionary<int, Lazy<ActiveHandlerTrackingEntry>>();
-			_entryFactory = (key, requestData) =>
-			{
-				return new Lazy<ActiveHandlerTrackingEntry>(() => CreateHandlerEntry(key, requestData),
-					LazyThreadSafetyMode.ExecutionAndPublication);
-			};
+			return new Lazy<ActiveHandlerTrackingEntry>(() => CreateHandlerEntry(key, requestData),
+				LazyThreadSafetyMode.ExecutionAndPublication);
+		};
 
-			_expiredHandlers = new ConcurrentQueue<ExpiredHandlerTrackingEntry>();
-			_expiryCallback = ExpiryTimer_Tick;
+		_expiredHandlers = new ConcurrentQueue<ExpiredHandlerTrackingEntry>();
+		_expiryCallback = ExpiryTimer_Tick;
 
-			_cleanupTimerLock = new object();
-			_cleanupActiveLock = new object();
-		}
-
-		public HttpClient CreateClient(RequestData requestData)
-		{
-			if (requestData == null) throw new ArgumentNullException(nameof(requestData));
+		_cleanupTimerLock = new object();
+		_cleanupActiveLock = new object();
+	}
 
-			var key = HttpTransportClient.GetClientKey(requestData);
-			var handler = CreateHandler(key, requestData);
-			var client = new HttpClient(handler, disposeHandler: false)
-			{
-				Timeout = requestData.RequestTimeout
-			};
-			return client;
-		}
+	public HttpClient CreateClient(RequestData requestData)
+	{
+		if (requestData == null) throw new ArgumentNullException(nameof(requestData));
 
-		private HttpMessageHandler CreateHandler(int key, RequestData requestData)
+		var key = HttpTransportClient.GetClientKey(requestData);
+		var handler = CreateHandler(key, requestData);
+		var client = new HttpClient(handler, disposeHandler: false)
 		{
-			if (requestData == null) throw new ArgumentNullException(nameof(requestData));
+			Timeout = requestData.RequestTimeout
+		};
+		return client;
+	}
+
+	private HttpMessageHandler CreateHandler(int key, RequestData requestData)
+	{
+		if (requestData == null) throw new ArgumentNullException(nameof(requestData));
 
 #if !NETSTANDARD2_0 && !NETFRAMEWORK
-			var entry = _activeHandlers.GetOrAdd(key, (k, r) => _entryFactory(k, r), requestData).Value;
+		var entry = _activeHandlers.GetOrAdd(key, (k, r) => _entryFactory(k, r), requestData).Value;
 #else
-			var entry = _activeHandlers.GetOrAdd(key, (k) => _entryFactory(k, requestData)).Value;
+		var entry = _activeHandlers.GetOrAdd(key, (k) => _entryFactory(k, requestData)).Value;
 #endif
 
-			StartHandlerEntryTimer(entry);
+		StartHandlerEntryTimer(entry);
 
-			return entry.Handler;
-		}
+		return entry.Handler;
+	}
 
-		private ActiveHandlerTrackingEntry CreateHandlerEntry(int key, RequestData requestData)
-		{
-			// Wrap the handler so we can ensure the inner handler outlives the outer handler.
-			var handler = new LifetimeTrackingHttpMessageHandler(_createHttpClientHandler(requestData));
+	private ActiveHandlerTrackingEntry CreateHandlerEntry(int key, RequestData requestData)
+	{
+		// Wrap the handler so we can ensure the inner handler outlives the outer handler.
+		var handler = new LifetimeTrackingHttpMessageHandler(_createHttpClientHandler(requestData));
 
-			// Note that we can't start the timer here. That would introduce a very very subtle race condition
-			// with very short expiry times. We need to wait until we've actually handed out the handler once
-			// to start the timer.
-			//
-			// Otherwise it would be possible that we start the timer here, immediately expire it (very short
-			// timer) and then dispose it without ever creating a client. That would be bad. It's unlikely
-			// this would happen, but we want to be sure.
-			return new ActiveHandlerTrackingEntry(key, handler, requestData.DnsRefreshTimeout);
-		}
+		// Note that we can't start the timer here. That would introduce a very very subtle race condition
+		// with very short expiry times. We need to wait until we've actually handed out the handler once
+		// to start the timer.
+		//
+		// Otherwise it would be possible that we start the timer here, immediately expire it (very short
+		// timer) and then dispose it without ever creating a client. That would be bad. It's unlikely
+		// this would happen, but we want to be sure.
+		return new ActiveHandlerTrackingEntry(key, handler, requestData.DnsRefreshTimeout);
+	}
 
-		private void ExpiryTimer_Tick(object state)
-		{
-			var active = (ActiveHandlerTrackingEntry)state;
-
-			// The timer callback should be the only one removing from the active collection. If we can't find
-			// our entry in the collection, then this is a bug.
-			var removed = _activeHandlers.TryRemove(active.Key, out var found);
-			if (removed)
-				Interlocked.Increment(ref _removedHandlers);
-			Debug.Assert(removed, "Entry not found. We should always be able to remove the entry");
-			// ReSharper disable once RedundantNameQualifier
-			Debug.Assert(object.ReferenceEquals(active, found.Value), "Different entry found. The entry should not have been replaced");
-
-			// At this point the handler is no longer 'active' and will not be handed out to any new clients.
-			// However we haven't dropped our strong reference to the handler, so we can't yet determine if
-			// there are still any other outstanding references (we know there is at least one).
-			//
-			// We use a different state object to track expired handlers. This allows any other thread that acquired
-			// the 'active' entry to use it without safety problems.
-			var expired = new ExpiredHandlerTrackingEntry(active);
-			_expiredHandlers.Enqueue(expired);
+	private void ExpiryTimer_Tick(object state)
+	{
+		var active = (ActiveHandlerTrackingEntry)state;
+
+		// The timer callback should be the only one removing from the active collection. If we can't find
+		// our entry in the collection, then this is a bug.
+		var removed = _activeHandlers.TryRemove(active.Key, out var found);
+		if (removed)
+			Interlocked.Increment(ref _removedHandlers);
+		Debug.Assert(removed, "Entry not found. We should always be able to remove the entry");
+		// ReSharper disable once RedundantNameQualifier
+		Debug.Assert(object.ReferenceEquals(active, found.Value), "Different entry found. The entry should not have been replaced");
+
+		// At this point the handler is no longer 'active' and will not be handed out to any new clients.
+		// However we haven't dropped our strong reference to the handler, so we can't yet determine if
+		// there are still any other outstanding references (we know there is at least one).
+		//
+		// We use a different state object to track expired handlers. This allows any other thread that acquired
+		// the 'active' entry to use it without safety problems.
+		var expired = new ExpiredHandlerTrackingEntry(active);
+		_expiredHandlers.Enqueue(expired);
 
-			StartCleanupTimer();
-		}
+		StartCleanupTimer();
+	}
 
-		protected virtual void StartHandlerEntryTimer(ActiveHandlerTrackingEntry entry) => entry.StartExpiryTimer(_expiryCallback);
+	private void StartHandlerEntryTimer(ActiveHandlerTrackingEntry entry) => entry.StartExpiryTimer(_expiryCallback);
 
-		protected virtual void StartCleanupTimer()
-		{
-			lock (_cleanupTimerLock)
-				_cleanupTimer ??= NonCapturingTimer.Create(CleanupCallback, this, _defaultCleanupInterval, Timeout.InfiniteTimeSpan);
-		}
+	private void StartCleanupTimer()
+	{
+		lock (_cleanupTimerLock)
+			_cleanupTimer ??= NonCapturingTimer.Create(CleanupCallback, this, _defaultCleanupInterval, Timeout.InfiniteTimeSpan);
+	}
 
-		protected virtual void StopCleanupTimer()
+	private void StopCleanupTimer()
+	{
+		lock (_cleanupTimerLock)
 		{
-			lock (_cleanupTimerLock)
-			{
-				_cleanupTimer?.Dispose();
-				_cleanupTimer = null;
-			}
+			_cleanupTimer?.Dispose();
+			_cleanupTimer = null;
 		}
+	}
 
-		private void CleanupTimer_Tick()
+	private void CleanupTimer_Tick()
+	{
+		// Stop any pending timers, we'll restart the timer if there's anything left to process after cleanup.
+		//
+		// With the scheme we're using it's possible we could end up with some redundant cleanup operations.
+		// This is expected and fine.
+		//
+		// An alternative would be to take a lock during the whole cleanup process. This isn't ideal because it
+		// would result in threads executing ExpiryTimer_Tick as they would need to block on cleanup to figure out
+		// whether we need to start the timer.
+		StopCleanupTimer();
+
+		if (!Monitor.TryEnter(_cleanupActiveLock))
 		{
-			// Stop any pending timers, we'll restart the timer if there's anything left to process after cleanup.
+			// We don't want to run a concurrent cleanup cycle. This can happen if the cleanup cycle takes
+			// a long time for some reason. Since we're running user code inside Dispose, it's definitely
+			// possible.
 			//
-			// With the scheme we're using it's possible we could end up with some redundant cleanup operations.
-			// This is expected and fine.
-			//
-			// An alternative would be to take a lock during the whole cleanup process. This isn't ideal because it
-			// would result in threads executing ExpiryTimer_Tick as they would need to block on cleanup to figure out
-			// whether we need to start the timer.
-			StopCleanupTimer();
+			// If we end up in that position, just make sure the timer gets started again. It should be cheap
+			// to run a 'no-op' cleanup.
+			StartCleanupTimer();
+			return;
+		}
 
-			if (!Monitor.TryEnter(_cleanupActiveLock))
-			{
-				// We don't want to run a concurrent cleanup cycle. This can happen if the cleanup cycle takes
-				// a long time for some reason. Since we're running user code inside Dispose, it's definitely
-				// possible.
-				//
-				// If we end up in that position, just make sure the timer gets started again. It should be cheap
-				// to run a 'no-op' cleanup.
-				StartCleanupTimer();
-				return;
-			}
+		try
+		{
+			var initialCount = _expiredHandlers.Count;
 
-			try
+			for (var i = 0; i < initialCount; i++)
 			{
-				var initialCount = _expiredHandlers.Count;
+				// Since we're the only one removing from _expired, TryDequeue must always succeed.
+				_expiredHandlers.TryDequeue(out var entry);
+				Debug.Assert(entry != null, "Entry was null, we should always get an entry back from TryDequeue");
 
-				for (var i = 0; i < initialCount; i++)
+				if (entry.CanDispose)
 				{
-					// Since we're the only one removing from _expired, TryDequeue must always succeed.
-					_expiredHandlers.TryDequeue(out var entry);
-					Debug.Assert(entry != null, "Entry was null, we should always get an entry back from TryDequeue");
-
-					if (entry.CanDispose)
+					try
 					{
-						try
-						{
-							entry.InnerHandler.Dispose();
-						}
-						catch (Exception)
-						{
-							// ignored (ignored in HttpClientFactory too)
-						}
+						entry.InnerHandler.Dispose();
+					}
+					catch (Exception)
+					{
+						// ignored (ignored in HttpClientFactory too)
 					}
-					// If the entry is still live, put it back in the queue so we can process it
-					// during the next cleanup cycle.
-					else
-						_expiredHandlers.Enqueue(entry);
 				}
+				// If the entry is still live, put it back in the queue so we can process it
+				// during the next cleanup cycle.
+				else
+					_expiredHandlers.Enqueue(entry);
 			}
-			finally
-			{
-				Monitor.Exit(_cleanupActiveLock);
-			}
-
-			// We didn't totally empty the cleanup queue, try again later.
-			if (_expiredHandlers.Count > 0) StartCleanupTimer();
 		}
-
-		public void Dispose()
+		finally
 		{
-			//try to cleanup nicely
-			CleanupTimer_Tick();
-			_cleanupTimer?.Dispose();
+			Monitor.Exit(_cleanupActiveLock);
+		}
 
-			//CleanupTimer might not cleanup everything because it will only dispose if the WeakReference allows it.
-			// here we forcefully dispose a Client -> ConnectionSettings -> Connection -> RequestDataHttpClientFactory
-			var attempts = 0;
-			do
+		// We didn't totally empty the cleanup queue, try again later.
+		if (_expiredHandlers.Count > 0) StartCleanupTimer();
+	}
+
+	public void Dispose()
+	{
+		//try to cleanup nicely
+		CleanupTimer_Tick();
+		_cleanupTimer?.Dispose();
+
+		//CleanupTimer might not cleanup everything because it will only dispose if the WeakReference allows it.
+		// here we forcefully dispose a Client -> ConnectionSettings -> Connection -> RequestDataHttpClientFactory
+		var attempts = 0;
+		do
+		{
+			attempts++;
+			var initialCount = _expiredHandlers.Count;
+			for (var i = 0; i < initialCount; i++)
 			{
-				attempts++;
-				var initialCount = _expiredHandlers.Count;
-				for (var i = 0; i < initialCount; i++)
+				// Since we're the only one removing from _expired, TryDequeue must always succeed.
+				_expiredHandlers.TryDequeue(out var entry);
+				try
 				{
-					// Since we're the only one removing from _expired, TryDequeue must always succeed.
-					_expiredHandlers.TryDequeue(out var entry);
-					try
-					{
-						entry?.InnerHandler.Dispose();
-					}
-					catch (Exception)
-					{
-						// ignored (ignored in HttpClientFactory too)
-					}
+					entry?.InnerHandler.Dispose();
+				}
+				catch (Exception)
+				{
+					// ignored (ignored in HttpClientFactory too)
 				}
-			} while (attempts < 5 && _expiredHandlers.Count > 0);
+			}
+		} while (attempts < 5 && _expiredHandlers.Count > 0);
 
-		}
 	}
 }
 #endif
diff --git a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ValueStopWatch.cs b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ValueStopWatch.cs
index ef161b9..d4717de 100644
--- a/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ValueStopWatch.cs
+++ b/src/Elastic.Transport/Components/TransportClient/HandlerTracking/ValueStopWatch.cs
@@ -10,36 +10,35 @@
 using System;
 using System.Threading;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A convenience API for interacting with System.Threading.Timer in a way
+/// that doesn't capture the ExecutionContext. We should be using this (or equivalent)
+/// everywhere we use timers to avoid rooting any values stored in asynclocals.
+/// <para> https://github.com/dotnet/runtime/blob/master/src/libraries/Common/src/Extensions/ValueStopwatch/ValueStopwatch.cs </para>
+/// </summary>
+internal static class NonCapturingTimer
 {
-	/// <summary>
-	/// A convenience API for interacting with System.Threading.Timer in a way
-	/// that doesn't capture the ExecutionContext. We should be using this (or equivalent)
-	/// everywhere we use timers to avoid rooting any values stored in asynclocals.
-	/// <para> https://github.com/dotnet/runtime/blob/master/src/libraries/Common/src/Extensions/ValueStopwatch/ValueStopwatch.cs </para>
-	/// </summary>
-	internal static class NonCapturingTimer
+	public static Timer Create(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period)
 	{
-		public static Timer Create(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period)
-		{
-			if (callback == null) throw new ArgumentNullException(nameof(callback));
+		if (callback == null) throw new ArgumentNullException(nameof(callback));
 
-			// Don't capture the current ExecutionContext and its AsyncLocals onto the timer
-			var restoreFlow = false;
-			try
-			{
-				if (ExecutionContext.IsFlowSuppressed()) return new Timer(callback, state, dueTime, period);
+		// Don't capture the current ExecutionContext and its AsyncLocals onto the timer
+		var restoreFlow = false;
+		try
+		{
+			if (ExecutionContext.IsFlowSuppressed()) return new Timer(callback, state, dueTime, period);
 
-				ExecutionContext.SuppressFlow();
-				restoreFlow = true;
+			ExecutionContext.SuppressFlow();
+			restoreFlow = true;
 
-				return new Timer(callback, state, dueTime, period);
-			}
-			finally
-			{
-				// Restore the current ExecutionContext
-				if (restoreFlow) ExecutionContext.RestoreFlow();
-			}
+			return new Timer(callback, state, dueTime, period);
+		}
+		finally
+		{
+			// Restore the current ExecutionContext
+			if (restoreFlow) ExecutionContext.RestoreFlow();
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Components/TransportClient/HttpMethod.cs b/src/Elastic.Transport/Components/TransportClient/HttpMethod.cs
index 5927d2e..c0fd7e8 100644
--- a/src/Elastic.Transport/Components/TransportClient/HttpMethod.cs
+++ b/src/Elastic.Transport/Components/TransportClient/HttpMethod.cs
@@ -6,27 +6,26 @@
 
 // ReSharper disable InconsistentNaming
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary> Http Method of the API call to be performed </summary>
+public enum HttpMethod
 {
-	/// <summary> Http Method of the API call to be performed </summary>
-	public enum HttpMethod
-	{
-		[EnumMember(Value = "GET")]
+	[EnumMember(Value = "GET")]
 // These really do not need xmldocs, leave it to the reader if they feel inspired :)
 #pragma warning disable 1591
-		GET,
+	GET,
 
-		[EnumMember(Value = "POST")]
-		POST,
+	[EnumMember(Value = "POST")]
+	POST,
 
-		[EnumMember(Value = "PUT")]
-		PUT,
+	[EnumMember(Value = "PUT")]
+	PUT,
 
-		[EnumMember(Value = "DELETE")]
-		DELETE,
+	[EnumMember(Value = "DELETE")]
+	DELETE,
 
-		[EnumMember(Value = "HEAD")]
-		HEAD
+	[EnumMember(Value = "HEAD")]
+	HEAD
 #pragma warning restore 1591
-	}
 }
diff --git a/src/Elastic.Transport/Components/TransportClient/HttpTransportClient-FullFramework.cs b/src/Elastic.Transport/Components/TransportClient/HttpTransportClient-FullFramework.cs
index d204f30..5fda84c 100644
--- a/src/Elastic.Transport/Components/TransportClient/HttpTransportClient-FullFramework.cs
+++ b/src/Elastic.Transport/Components/TransportClient/HttpTransportClient-FullFramework.cs
@@ -7,7 +7,7 @@
 
 namespace Elastic.Transport
 {
-	/// <summary> The default ITransportClient implementation. Uses <see cref="HttpWebRequest" /> on the current .NET desktop framework.</summary>
-	public class HttpTransportClient : HttpWebRequestTransportClient { }
+	/// <summary> The default TransportClient implementation. Uses <see cref="HttpWebRequest" /> on the current .NET desktop framework.</summary>
+	public sealed class HttpTransportClient : HttpWebRequestTransportClient { }
 }
 #endif
diff --git a/src/Elastic.Transport/Components/TransportClient/HttpTransportClient.cs b/src/Elastic.Transport/Components/TransportClient/HttpTransportClient.cs
index 43265d7..29e33b8 100644
--- a/src/Elastic.Transport/Components/TransportClient/HttpTransportClient.cs
+++ b/src/Elastic.Transport/Components/TransportClient/HttpTransportClient.cs
@@ -14,506 +14,487 @@
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Net.NetworkInformation;
-using System.Security.Cryptography;
 using System.Threading;
 using System.Threading.Tasks;
 using Elastic.Transport.Diagnostics;
 using Elastic.Transport.Extensions;
 using static System.Net.DecompressionMethods;
 
-namespace Elastic.Transport
-{
-	internal class WebProxy : IWebProxy
-	{
-		private readonly Uri _uri;
-
-		public WebProxy(Uri uri) => _uri = uri;
-
-		public ICredentials Credentials { get; set; }
-
-		public Uri GetProxy(Uri destination) => _uri;
-
-		public bool IsBypassed(Uri host) => host.IsLoopback;
-	}
+namespace Elastic.Transport;
 
-	/// <summary> The default ITransportClient implementation. Uses <see cref="HttpClient" />.</summary>
-	public class HttpTransportClient : ITransportClient
-	{
-		private static readonly string MissingConnectionLimitMethodError =
-			$"Your target platform does not support {nameof(TransportConfiguration.ConnectionLimit)}"
-			+ $" please set {nameof(TransportConfiguration.ConnectionLimit)} to -1 on your connection configuration/settings."
-			+ $" this will cause the {nameof(HttpClientHandler.MaxConnectionsPerServer)} not to be set on {nameof(HttpClientHandler)}";
+/// <summary> The default TransportClient implementation. Uses <see cref="HttpClient" />.</summary>
+public class HttpTransportClient : TransportClient
+{
+	private static readonly string MissingConnectionLimitMethodError =
+		$"Your target platform does not support {nameof(TransportConfiguration.ConnectionLimit)}"
+		+ $" please set {nameof(TransportConfiguration.ConnectionLimit)} to -1 on your connection configuration/settings."
+		+ $" this will cause the {nameof(HttpClientHandler.MaxConnectionsPerServer)} not to be set on {nameof(HttpClientHandler)}";
 
-		private string _expectedCertificateFingerprint;
+	private string _expectedCertificateFingerprint;
 
-		/// <inheritdoc cref="HttpTransportClient" />
-		public HttpTransportClient() => HttpClientFactory = new RequestDataHttpClientFactory(r => CreateHttpClientHandler(r));
+	/// <inheritdoc cref="HttpTransportClient" />
+	public HttpTransportClient() => HttpClientFactory = new RequestDataHttpClientFactory(r => CreateHttpClientHandler(r));
 
-		/// <inheritdoc cref="RequestDataHttpClientFactory.InUseHandlers" />
-		public int InUseHandlers => HttpClientFactory.InUseHandlers;
+	/// <inheritdoc cref="RequestDataHttpClientFactory.InUseHandlers" />
+	public int InUseHandlers => HttpClientFactory.InUseHandlers;
 
-		/// <inheritdoc cref="RequestDataHttpClientFactory.RemovedHandlers" />
-		public int RemovedHandlers => HttpClientFactory.RemovedHandlers;
+	/// <inheritdoc cref="RequestDataHttpClientFactory.RemovedHandlers" />
+	public int RemovedHandlers => HttpClientFactory.RemovedHandlers;
 
-		private static DiagnosticSource DiagnosticSource { get; } = new DiagnosticListener(DiagnosticSources.HttpConnection.SourceName);
+	private static DiagnosticSource DiagnosticSource { get; } = new DiagnosticListener(DiagnosticSources.HttpConnection.SourceName);
 
-		private RequestDataHttpClientFactory HttpClientFactory { get; }
+	private RequestDataHttpClientFactory HttpClientFactory { get; }
 
-		/// <inheritdoc cref="ITransportClient.Request{TResponse}" />
-		public virtual TResponse Request<TResponse>(RequestData requestData)
-			where TResponse : class, ITransportResponse, new()
+	/// <inheritdoc cref="TransportClient.Request{TResponse}" />
+	public override TResponse Request<TResponse>(RequestData requestData)
+	{
+		var client = GetClient(requestData);
+		HttpResponseMessage responseMessage;
+		int? statusCode = null;
+		Stream responseStream = null;
+		Exception ex = null;
+		string mimeType = null;
+		long contentLength = -1;
+		IDisposable receive = DiagnosticSources.SingletonDisposable;
+		ReadOnlyDictionary<TcpState, int> tcpStats = null;
+		ReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats = null;
+		Dictionary<string, IEnumerable<string>> responseHeaders = null;
+
+		try
 		{
-			var client = GetClient(requestData);
-			HttpResponseMessage responseMessage;
-			int? statusCode = null;
-			Stream responseStream = null;
-			Exception ex = null;
-			string mimeType = null;
-			long contentLength = -1;
-			IDisposable receive = DiagnosticSources.SingletonDisposable;
-			ReadOnlyDictionary<TcpState, int> tcpStats = null;
-			ReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats = null;
-			Dictionary<string, IEnumerable<string>> responseHeaders = null;
+			var requestMessage = CreateHttpRequestMessage(requestData);
 
-			try
-			{
-				var requestMessage = CreateHttpRequestMessage(requestData);
+			if (requestData.PostData != null)
+				SetContent(requestMessage, requestData);
 
-				if (requestData.PostData != null)
-					SetContent(requestMessage, requestData);
-
-				using (requestMessage?.Content ?? (IDisposable)Stream.Null)
-				using (var d = DiagnosticSource.Diagnose<RequestData, int?>(DiagnosticSources.HttpConnection.SendAndReceiveHeaders, requestData))
-				{
-					if (requestData.TcpStats)
-						tcpStats = TcpStats.GetStates();
+			using (requestMessage?.Content ?? (IDisposable)Stream.Null)
+			using (var d = DiagnosticSource.Diagnose<RequestData, int?>(DiagnosticSources.HttpConnection.SendAndReceiveHeaders, requestData))
+			{
+				if (requestData.TcpStats)
+					tcpStats = TcpStats.GetStates();
 
-					if (requestData.ThreadPoolStats)
-						threadPoolStats = ThreadPoolStats.GetStats();
+				if (requestData.ThreadPoolStats)
+					threadPoolStats = ThreadPoolStats.GetStats();
 
 #if NET5_0_OR_GREATER
-					responseMessage = client.Send(requestMessage, HttpCompletionOption.ResponseHeadersRead);
+				responseMessage = client.Send(requestMessage, HttpCompletionOption.ResponseHeadersRead);
 #else
-					responseMessage = client.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead).GetAwaiter().GetResult();
+				responseMessage = client.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead).GetAwaiter().GetResult();
 #endif
-					statusCode = (int)responseMessage.StatusCode;
-					d.EndState = statusCode;
-				}
+				statusCode = (int)responseMessage.StatusCode;
+				d.EndState = statusCode;
+			}
 
-				requestData.MadeItToResponse = true;
-				responseHeaders = ParseHeaders(requestData, responseMessage, responseHeaders);
-				contentLength = responseMessage.Content.Headers.ContentLength ?? -1;
-				mimeType = responseMessage.Content.Headers.ContentType?.MediaType;
+			requestData.MadeItToResponse = true;
+			responseHeaders = ParseHeaders(requestData, responseMessage, responseHeaders);
+			contentLength = responseMessage.Content.Headers.ContentLength ?? -1;
+			mimeType = responseMessage.Content.Headers.ContentType?.MediaType;
 
-				if (responseMessage.Content != null)
-				{
-					receive = DiagnosticSource.Diagnose(DiagnosticSources.HttpConnection.ReceiveBody, requestData, statusCode);
+			if (responseMessage.Content != null)
+			{
+				receive = DiagnosticSource.Diagnose(DiagnosticSources.HttpConnection.ReceiveBody, requestData, statusCode);
 
 #if NET5_0_OR_GREATER
-					responseStream = responseMessage.Content.ReadAsStream();
+				responseStream = responseMessage.Content.ReadAsStream();
 #else
-					responseStream = responseMessage.Content.ReadAsStreamAsync().GetAwaiter().GetResult();
+				responseStream = responseMessage.Content.ReadAsStreamAsync().GetAwaiter().GetResult();
 #endif
-				}
 			}
-			catch (TaskCanceledException e)
-			{
-				ex = e;
-			}
-			catch (HttpRequestException e)
-			{
-				ex = e;
-			}
-			using (receive)
-			using (responseStream ??= Stream.Null)
-			{
-				var response = requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponse<TResponse>(requestData, ex, statusCode, responseHeaders, responseStream, mimeType,
-					contentLength, threadPoolStats, tcpStats);
+		}
+		catch (TaskCanceledException e)
+		{
+			ex = e;
+		}
+		catch (HttpRequestException e)
+		{
+			ex = e;
+		}
+		using (receive)
+		using (responseStream ??= Stream.Null)
+		{
+			var response = requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponse<TResponse>(requestData, ex, statusCode, responseHeaders, responseStream, mimeType,
+				contentLength, threadPoolStats, tcpStats);
 
-				return response;
-			}
+			return response;
 		}
+	}
 
-		/// <inheritdoc cref="ITransportClient.RequestAsync{TResponse}" />
-		public virtual async Task<TResponse> RequestAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken)
-			where TResponse : class, ITransportResponse, new()
+	/// <inheritdoc cref="TransportClient.RequestAsync{TResponse}" />
+	public override async Task<TResponse> RequestAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken)
+	{
+		var client = GetClient(requestData);
+		HttpResponseMessage responseMessage;
+		int? statusCode = null;
+		Stream responseStream = null;
+		Exception ex = null;
+		string mimeType = null;
+		long contentLength = -1;
+		IDisposable receive = DiagnosticSources.SingletonDisposable;
+		ReadOnlyDictionary<TcpState, int> tcpStats = null;
+		ReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats = null;
+		Dictionary<string, IEnumerable<string>> responseHeaders = null;
+		requestData.IsAsync = true;
+
+		try
 		{
-			var client = GetClient(requestData);
-			HttpResponseMessage responseMessage;
-			int? statusCode = null;
-			Stream responseStream = null;
-			Exception ex = null;
-			string mimeType = null;
-			long contentLength = -1;
-			IDisposable receive = DiagnosticSources.SingletonDisposable;
-			ReadOnlyDictionary<TcpState, int> tcpStats = null;
-			ReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats = null;
-			Dictionary<string, IEnumerable<string>> responseHeaders = null;
-			requestData.IsAsync = true;
+			var requestMessage = CreateHttpRequestMessage(requestData);
 
-			try
-			{
-				var requestMessage = CreateHttpRequestMessage(requestData);
-
-				if (requestData.PostData != null)
-					await SetContentAsync(requestMessage, requestData, cancellationToken).ConfigureAwait(false);
+			if (requestData.PostData != null)
+				await SetContentAsync(requestMessage, requestData, cancellationToken).ConfigureAwait(false);
 
-				using (requestMessage?.Content ?? (IDisposable)Stream.Null)
-				using (var d = DiagnosticSource.Diagnose<RequestData, int?>(DiagnosticSources.HttpConnection.SendAndReceiveHeaders, requestData))
-				{
-					if (requestData.TcpStats)
-						tcpStats = TcpStats.GetStates();
+			using (requestMessage?.Content ?? (IDisposable)Stream.Null)
+			using (var d = DiagnosticSource.Diagnose<RequestData, int?>(DiagnosticSources.HttpConnection.SendAndReceiveHeaders, requestData))
+			{
+				if (requestData.TcpStats)
+					tcpStats = TcpStats.GetStates();
 
-					if (requestData.ThreadPoolStats)
-						threadPoolStats = ThreadPoolStats.GetStats();
+				if (requestData.ThreadPoolStats)
+					threadPoolStats = ThreadPoolStats.GetStats();
 
-					responseMessage = await client.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
-						.ConfigureAwait(false);
-					statusCode = (int)responseMessage.StatusCode;
-					d.EndState = statusCode;
-				}
+				responseMessage = await client.SendAsync(requestMessage, HttpCompletionOption.ResponseHeadersRead, cancellationToken)
+					.ConfigureAwait(false);
+				statusCode = (int)responseMessage.StatusCode;
+				d.EndState = statusCode;
+			}
 
-				requestData.MadeItToResponse = true;
-				mimeType = responseMessage.Content.Headers.ContentType?.MediaType;
-				contentLength = responseMessage.Content.Headers.ContentLength ?? -1;
-				responseHeaders = ParseHeaders(requestData, responseMessage, responseHeaders);
+			requestData.MadeItToResponse = true;
+			mimeType = responseMessage.Content.Headers.ContentType?.MediaType;
+			contentLength = responseMessage.Content.Headers.ContentLength ?? -1;
+			responseHeaders = ParseHeaders(requestData, responseMessage, responseHeaders);
 
-				if (responseMessage.Content != null)
-				{
-					receive = DiagnosticSource.Diagnose(DiagnosticSources.HttpConnection.ReceiveBody, requestData, statusCode);
-					responseStream = await responseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
-				}
-			}
-			catch (TaskCanceledException e)
+			if (responseMessage.Content != null)
 			{
-				ex = e;
-			}
-			catch (HttpRequestException e)
-			{
-				ex = e;
-			}
-			using (receive)
-			using (responseStream ??= Stream.Null)
-			{
-				var response = await requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponseAsync<TResponse>
-						(requestData, ex, statusCode, responseHeaders, responseStream, mimeType, contentLength, threadPoolStats, tcpStats, cancellationToken)
-					.ConfigureAwait(false);
-				return response;
+				receive = DiagnosticSource.Diagnose(DiagnosticSources.HttpConnection.ReceiveBody, requestData, statusCode);
+				responseStream = await responseMessage.Content.ReadAsStreamAsync().ConfigureAwait(false);
 			}
 		}
+		catch (TaskCanceledException e)
+		{
+			ex = e;
+		}
+		catch (HttpRequestException e)
+		{
+			ex = e;
+		}
+		using (receive)
+		using (responseStream ??= Stream.Null)
+		{
+			var response = await requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponseAsync<TResponse>
+					(requestData, ex, statusCode, responseHeaders, responseStream, mimeType, contentLength, threadPoolStats, tcpStats, cancellationToken)
+				.ConfigureAwait(false);
+			return response;
+		}
+	}
 
-		private static Dictionary<string, IEnumerable<string>> ParseHeaders(RequestData requestData, HttpResponseMessage responseMessage, Dictionary<string, IEnumerable<string>> responseHeaders)
+	private static Dictionary<string, IEnumerable<string>> ParseHeaders(RequestData requestData, HttpResponseMessage responseMessage, Dictionary<string, IEnumerable<string>> responseHeaders)
+	{
+		if (requestData.ParseAllHeaders)
 		{
-			if (requestData.ParseAllHeaders)
+			foreach (var header in responseMessage.Headers)
 			{
-				foreach (var header in responseMessage.Headers)
-				{
-					responseHeaders ??= new Dictionary<string, IEnumerable<string>>();
-					responseHeaders.Add(header.Key, header.Value);
-				}
+				responseHeaders ??= new Dictionary<string, IEnumerable<string>>();
+				responseHeaders.Add(header.Key, header.Value);
 			}
-			else if (requestData.ResponseHeadersToParse.Count > 0)
+		}
+		else if (requestData.ResponseHeadersToParse.Count > 0)
+		{
+			foreach (var headerToParse in requestData.ResponseHeadersToParse)
 			{
-				foreach (var headerToParse in requestData.ResponseHeadersToParse)
+				if (responseMessage.Headers.TryGetValues(headerToParse, out var values))
 				{
-					if (responseMessage.Headers.TryGetValues(headerToParse, out var values))
-					{
-						responseHeaders ??= new Dictionary<string, IEnumerable<string>>();
-						responseHeaders.Add(headerToParse, values);
-					}
+					responseHeaders ??= new Dictionary<string, IEnumerable<string>>();
+					responseHeaders.Add(headerToParse, values);
 				}
 			}
-
-			return responseHeaders;
 		}
 
-		void IDisposable.Dispose() => DisposeManagedResources();
-
-		private HttpClient GetClient(RequestData requestData) => HttpClientFactory.CreateClient(requestData);
-
-		/// <summary>
-		/// Creates an instance of <see cref="HttpMessageHandler" /> using the <paramref name="requestData" />.
-		/// This method is virtual so subclasses of <see cref="HttpTransportClient" /> can modify the instance if needed.
-		/// </summary>
-		/// <param name="requestData">An instance of <see cref="RequestData" /> describing where and how to call out to</param>
-		/// <exception cref="Exception">
-		/// Can throw if <see cref="ITransportConfiguration.ConnectionLimit" /> is set but the platform does
-		/// not allow this to be set on <see cref="HttpClientHandler.MaxConnectionsPerServer" />
-		/// </exception>
-		protected virtual HttpMessageHandler CreateHttpClientHandler(RequestData requestData)
-		{
-			var handler = new HttpClientHandler { AutomaticDecompression = requestData.HttpCompression ? GZip | Deflate : None, };
+		return responseHeaders;
+	}
 
-			// same limit as desktop clr
-			if (requestData.ConnectionSettings.ConnectionLimit > 0)
-				try
-				{
-					handler.MaxConnectionsPerServer = requestData.ConnectionSettings.ConnectionLimit;
-				}
-				catch (MissingMethodException e)
-				{
-					throw new Exception(MissingConnectionLimitMethodError, e);
-				}
-				catch (PlatformNotSupportedException e)
-				{
-					throw new Exception(MissingConnectionLimitMethodError, e);
-				}
+	private HttpClient GetClient(RequestData requestData) => HttpClientFactory.CreateClient(requestData);
+
+	/// <summary>
+	/// Creates an instance of <see cref="HttpMessageHandler" /> using the <paramref name="requestData" />.
+	/// This method is virtual so subclasses of <see cref="HttpTransportClient" /> can modify the instance if needed.
+	/// </summary>
+	/// <param name="requestData">An instance of <see cref="RequestData" /> describing where and how to call out to</param>
+	/// <exception cref="Exception">
+	/// Can throw if <see cref="ITransportConfiguration.ConnectionLimit" /> is set but the platform does
+	/// not allow this to be set on <see cref="HttpClientHandler.MaxConnectionsPerServer" />
+	/// </exception>
+	protected virtual HttpMessageHandler CreateHttpClientHandler(RequestData requestData)
+	{
+		var handler = new HttpClientHandler { AutomaticDecompression = requestData.HttpCompression ? GZip | Deflate : None, };
 
-			if (!requestData.ProxyAddress.IsNullOrEmpty())
+		// same limit as desktop clr
+		if (requestData.ConnectionSettings.ConnectionLimit > 0)
+			try
 			{
-				var uri = new Uri(requestData.ProxyAddress);
-				var proxy = new WebProxy(uri);
-				if (!string.IsNullOrEmpty(requestData.ProxyUsername))
-				{
-					var credentials = new NetworkCredential(requestData.ProxyUsername, requestData.ProxyPassword);
-					proxy.Credentials = credentials;
-				}
-				handler.Proxy = proxy;
+				handler.MaxConnectionsPerServer = requestData.ConnectionSettings.ConnectionLimit;
 			}
-			else if (requestData.DisableAutomaticProxyDetection) handler.UseProxy = false;
-
-			// Configure certificate validation
-			var callback = requestData.ConnectionSettings?.ServerCertificateValidationCallback;
-			if (callback != null && handler.ServerCertificateCustomValidationCallback == null)
+			catch (MissingMethodException e)
 			{
-				handler.ServerCertificateCustomValidationCallback = callback;
+				throw new Exception(MissingConnectionLimitMethodError, e);
 			}
-			else if (!string.IsNullOrEmpty(requestData.ConnectionSettings.CertificateFingerprint))
+			catch (PlatformNotSupportedException e)
 			{
-				handler.ServerCertificateCustomValidationCallback = (request, certificate, chain, policyErrors) =>
-				{
-					if (certificate is null && chain is null) return false;
-
-					// The "cleaned", expected fingerprint is cached to avoid repeated cost of converting it to a comparable form.
-					_expectedCertificateFingerprint ??= CertificateHelpers.ComparableFingerprint(requestData.ConnectionSettings.CertificateFingerprint);
-
-					// If there is a chain, check each certificate up to the root
-					if (chain is not null)
-					{
-						foreach (var element in chain.ChainElements)
-						{
-							if (CertificateHelpers.ValidateCertificateFingerprint(element.Certificate, _expectedCertificateFingerprint))
-								return true;
-						}
-					}
-
-					// Otherwise, check the certificate
-					return CertificateHelpers.ValidateCertificateFingerprint(certificate, _expectedCertificateFingerprint);
-				};
+				throw new Exception(MissingConnectionLimitMethodError, e);
 			}
 
-			if (requestData.ClientCertificates != null)
+		if (!requestData.ProxyAddress.IsNullOrEmpty())
+		{
+			var uri = new Uri(requestData.ProxyAddress);
+			var proxy = new WebProxy(uri);
+			if (!string.IsNullOrEmpty(requestData.ProxyUsername))
 			{
-				handler.ClientCertificateOptions = ClientCertificateOption.Manual;
-				handler.ClientCertificates.AddRange(requestData.ClientCertificates);
+				var credentials = new NetworkCredential(requestData.ProxyUsername, requestData.ProxyPassword);
+				proxy.Credentials = credentials;
 			}
-
-			return handler;
+			handler.Proxy = proxy;
 		}
+		else if (requestData.DisableAutomaticProxyDetection) handler.UseProxy = false;
 
-		private string ComparableFingerprint(string fingerprint)
+		// Configure certificate validation
+		var callback = requestData.ConnectionSettings?.ServerCertificateValidationCallback;
+		if (callback != null && handler.ServerCertificateCustomValidationCallback == null)
+		{
+			handler.ServerCertificateCustomValidationCallback = callback;
+		}
+		else if (!string.IsNullOrEmpty(requestData.ConnectionSettings.CertificateFingerprint))
 		{
-			var finalFingerprint = fingerprint;
+			handler.ServerCertificateCustomValidationCallback = (request, certificate, chain, policyErrors) =>
+			{
+				if (certificate is null && chain is null) return false;
 
-			if (fingerprint.Contains(':'))
-				finalFingerprint = fingerprint.Replace(":", string.Empty);
+				// The "cleaned", expected fingerprint is cached to avoid repeated cost of converting it to a comparable form.
+				_expectedCertificateFingerprint ??= CertificateHelpers.ComparableFingerprint(requestData.ConnectionSettings.CertificateFingerprint);
 
-			return finalFingerprint;
+				// If there is a chain, check each certificate up to the root
+				if (chain is not null)
+				{
+					foreach (var element in chain.ChainElements)
+					{
+						if (CertificateHelpers.ValidateCertificateFingerprint(element.Certificate, _expectedCertificateFingerprint))
+							return true;
+					}
+				}
+
+				// Otherwise, check the certificate
+				return CertificateHelpers.ValidateCertificateFingerprint(certificate, _expectedCertificateFingerprint);
+			};
 		}
 
-		/// <summary>
-		/// Creates an instance of <see cref="HttpRequestMessage" /> using the <paramref name="requestData" />.
-		/// This method is virtual so subclasses of <see cref="HttpTransportClient" /> can modify the instance if needed.
-		/// </summary>
-		/// <param name="requestData">An instance of <see cref="RequestData" /> describing where and how to call out to</param>
-		/// <exception cref="Exception">
-		/// Can throw if <see cref="ITransportConfiguration.ConnectionLimit" /> is set but the platform does
-		/// not allow this to be set on <see cref="HttpClientHandler.MaxConnectionsPerServer" />
-		/// </exception>
-		protected virtual HttpRequestMessage CreateHttpRequestMessage(RequestData requestData)
+		if (requestData.ClientCertificates != null)
 		{
-			var request = CreateRequestMessage(requestData);
-			SetAuthenticationIfNeeded(request, requestData);
-			return request;
+			handler.ClientCertificateOptions = ClientCertificateOption.Manual;
+			handler.ClientCertificates.AddRange(requestData.ClientCertificates);
 		}
 
-		/// <summary> Isolated hook for subclasses to set authentication on <paramref name="requestMessage" /> </summary>
-		/// <param name="requestMessage">The instance of <see cref="HttpRequestMessage" /> that needs authentication details</param>
-		/// <param name="requestData">An object describing where and how we want to call out to</param>
-		protected virtual void SetAuthenticationIfNeeded(HttpRequestMessage requestMessage, RequestData requestData)
-		{
-			//If user manually specifies an Authorization Header give it preference
-			if (requestData.Headers.HasKeys() && requestData.Headers.AllKeys.Contains("Authorization"))
-			{
-				var header = AuthenticationHeaderValue.Parse(requestData.Headers["Authorization"]);
-				requestMessage.Headers.Authorization = header;
-				return;
-			}
+		return handler;
+	}
 
-			SetConfiguredAuthenticationHeaderIfNeeded(requestMessage, requestData);
-		}
+	private string ComparableFingerprint(string fingerprint)
+	{
+		var finalFingerprint = fingerprint;
 
-		private static void SetConfiguredAuthenticationHeaderIfNeeded(HttpRequestMessage requestMessage, RequestData requestData)
-		{
-			// Basic auth credentials take the following precedence (highest -> lowest):
-			// 1 - Specified with the URI (highest precedence)
-			// 2 - Specified on the request
-			// 3 - Specified at the global ITransportClientSettings level (lowest precedence)
-
-			string parameters = null;
-			string scheme = null;
-			if (!requestData.Uri.UserInfo.IsNullOrEmpty())
-			{
-				parameters = BasicAuthentication.GetBase64String(Uri.UnescapeDataString(requestData.Uri.UserInfo));
-				scheme = BasicAuthentication.BasicAuthenticationScheme;
-			}
-			else if (requestData.AuthenticationHeader != null && requestData.AuthenticationHeader.TryGetAuthorizationParameters(out var v))
-			{
-				parameters = v;
-				scheme = requestData.AuthenticationHeader.AuthScheme;
-			}
+		if (fingerprint.Contains(':'))
+			finalFingerprint = fingerprint.Replace(":", string.Empty);
+
+		return finalFingerprint;
+	}
 
-			if (parameters.IsNullOrEmpty()) return;
+	/// <summary>
+	/// Creates an instance of <see cref="HttpRequestMessage" /> using the <paramref name="requestData" />.
+	/// This method is virtual so subclasses of <see cref="HttpTransportClient" /> can modify the instance if needed.
+	/// </summary>
+	/// <param name="requestData">An instance of <see cref="RequestData" /> describing where and how to call out to</param>
+	/// <exception cref="Exception">
+	/// Can throw if <see cref="ITransportConfiguration.ConnectionLimit" /> is set but the platform does
+	/// not allow this to be set on <see cref="HttpClientHandler.MaxConnectionsPerServer" />
+	/// </exception>
+	internal HttpRequestMessage CreateHttpRequestMessage(RequestData requestData)
+	{
+		var request = CreateRequestMessage(requestData);
+		SetAuthenticationIfNeeded(request, requestData);
+		return request;
+	}
 
-			requestMessage.Headers.Authorization = new AuthenticationHeaderValue(scheme, parameters);
+	/// <summary> Isolated hook for subclasses to set authentication on <paramref name="requestMessage" /> </summary>
+	/// <param name="requestMessage">The instance of <see cref="HttpRequestMessage" /> that needs authentication details</param>
+	/// <param name="requestData">An object describing where and how we want to call out to</param>
+	internal void SetAuthenticationIfNeeded(HttpRequestMessage requestMessage, RequestData requestData)
+	{
+		//If user manually specifies an Authorization Header give it preference
+		if (requestData.Headers.HasKeys() && requestData.Headers.AllKeys.Contains("Authorization"))
+		{
+			var header = AuthenticationHeaderValue.Parse(requestData.Headers["Authorization"]);
+			requestMessage.Headers.Authorization = header;
+			return;
 		}
 
-		private static HttpRequestMessage CreateRequestMessage(RequestData requestData)
+		SetConfiguredAuthenticationHeaderIfNeeded(requestMessage, requestData);
+	}
+
+	private static void SetConfiguredAuthenticationHeaderIfNeeded(HttpRequestMessage requestMessage, RequestData requestData)
+	{
+		// Basic auth credentials take the following precedence (highest -> lowest):
+		// 1 - Specified with the URI (highest precedence)
+		// 2 - Specified on the request
+		// 3 - Specified at the global TransportClientSettings level (lowest precedence)
+
+		string parameters = null;
+		string scheme = null;
+		if (!requestData.Uri.UserInfo.IsNullOrEmpty())
+		{
+			parameters = BasicAuthentication.GetBase64String(Uri.UnescapeDataString(requestData.Uri.UserInfo));
+			scheme = BasicAuthentication.BasicAuthenticationScheme;
+		}
+		else if (requestData.AuthenticationHeader != null && requestData.AuthenticationHeader.TryGetAuthorizationParameters(out var v))
 		{
-			var method = ConvertHttpMethod(requestData.Method);
-			var requestMessage = new HttpRequestMessage(method, requestData.Uri);
+			parameters = v;
+			scheme = requestData.AuthenticationHeader.AuthScheme;
+		}
+
+		if (parameters.IsNullOrEmpty()) return;
 
-			if (requestData.Headers != null)
-				foreach (string key in requestData.Headers)
-					requestMessage.Headers.TryAddWithoutValidation(key, requestData.Headers.GetValues(key));
+		requestMessage.Headers.Authorization = new AuthenticationHeaderValue(scheme, parameters);
+	}
 
-			requestMessage.Headers.Connection.Clear();
-			requestMessage.Headers.ConnectionClose = false;
-			requestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(requestData.Accept));
+	private static HttpRequestMessage CreateRequestMessage(RequestData requestData)
+	{
+		var method = ConvertHttpMethod(requestData.Method);
+		var requestMessage = new HttpRequestMessage(method, requestData.Uri);
 
-			var userAgent = requestData.UserAgent?.ToString();
-			if (!string.IsNullOrWhiteSpace(userAgent))
-			{
-				requestMessage.Headers.UserAgent.Clear();
-				requestMessage.Headers.UserAgent.TryParseAdd(userAgent);
-			}
+		if (requestData.Headers != null)
+			foreach (string key in requestData.Headers)
+				requestMessage.Headers.TryAddWithoutValidation(key, requestData.Headers.GetValues(key));
 
-			if (!requestData.RunAs.IsNullOrEmpty())
-				requestMessage.Headers.Add(RequestData.RunAsSecurityHeader, requestData.RunAs);
+		requestMessage.Headers.Connection.Clear();
+		requestMessage.Headers.ConnectionClose = false;
+		requestMessage.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(requestData.Accept));
 
-			if (requestData.MetaHeaderProvider is not null)
-			{
-				var value = requestData.MetaHeaderProvider.ProduceHeaderValue(requestData);
+		var userAgent = requestData.UserAgent?.ToString();
+		if (!string.IsNullOrWhiteSpace(userAgent))
+		{
+			requestMessage.Headers.UserAgent.Clear();
+			requestMessage.Headers.UserAgent.TryParseAdd(userAgent);
+		}
 
-				if (!string.IsNullOrEmpty(value))
-					requestMessage.Headers.TryAddWithoutValidation(requestData.MetaHeaderProvider.HeaderName, value);
-			}
+		if (!requestData.RunAs.IsNullOrEmpty())
+			requestMessage.Headers.Add(RequestData.RunAsSecurityHeader, requestData.RunAs);
 
-			return requestMessage;
+		if (requestData.MetaHeaderProvider is not null)
+		{
+			var value = requestData.MetaHeaderProvider.ProduceHeaderValue(requestData);
+
+			if (!string.IsNullOrEmpty(value))
+				requestMessage.Headers.TryAddWithoutValidation(requestData.MetaHeaderProvider.HeaderName, value);
 		}
 
-		private static void SetContent(HttpRequestMessage message, RequestData requestData)
+		return requestMessage;
+	}
+
+	private static void SetContent(HttpRequestMessage message, RequestData requestData)
+	{
+		if (requestData.TransferEncodingChunked)
+			message.Content = new RequestDataContent(requestData);
+		else
 		{
-			if (requestData.TransferEncodingChunked)
-				message.Content = new RequestDataContent(requestData);
-			else
+			var stream = requestData.MemoryStreamFactory.Create();
+			if (requestData.HttpCompression)
 			{
-				var stream = requestData.MemoryStreamFactory.Create();
-				if (requestData.HttpCompression)
-				{
-					using var zipStream = new GZipStream(stream, CompressionMode.Compress, true);
-					requestData.PostData.Write(zipStream, requestData.ConnectionSettings);
-				}
-				else
-					requestData.PostData.Write(stream, requestData.ConnectionSettings);
+				using var zipStream = new GZipStream(stream, CompressionMode.Compress, true);
+				requestData.PostData.Write(zipStream, requestData.ConnectionSettings);
+			}
+			else
+				requestData.PostData.Write(stream, requestData.ConnectionSettings);
 
-				// the written bytes are uncompressed, so can only be used when http compression isn't used
-				if (requestData.PostData.DisableDirectStreaming.GetValueOrDefault(false) && !requestData.HttpCompression)
-				{
-					message.Content = new ByteArrayContent(requestData.PostData.WrittenBytes);
-					stream.Dispose();
-				}
-				else
-				{
-					stream.Position = 0;
-					message.Content = new StreamContent(stream);
-				}
+			// the written bytes are uncompressed, so can only be used when http compression isn't used
+			if (requestData.PostData.DisableDirectStreaming.GetValueOrDefault(false) && !requestData.HttpCompression)
+			{
+				message.Content = new ByteArrayContent(requestData.PostData.WrittenBytes);
+				stream.Dispose();
+			}
+			else
+			{
+				stream.Position = 0;
+				message.Content = new StreamContent(stream);
+			}
 
-				if (requestData.HttpCompression)
-					message.Content.Headers.ContentEncoding.Add("gzip");
+			if (requestData.HttpCompression)
+				message.Content.Headers.ContentEncoding.Add("gzip");
 
-				message.Content.Headers.ContentType = new MediaTypeHeaderValue(requestData.RequestMimeType);
-			}
+			message.Content.Headers.ContentType = new MediaTypeHeaderValue(requestData.RequestMimeType);
 		}
+	}
 
-		private static async Task SetContentAsync(HttpRequestMessage message, RequestData requestData, CancellationToken cancellationToken)
+	private static async Task SetContentAsync(HttpRequestMessage message, RequestData requestData, CancellationToken cancellationToken)
+	{
+		if (requestData.TransferEncodingChunked)
+			message.Content = new RequestDataContent(requestData, cancellationToken);
+		else
 		{
-			if (requestData.TransferEncodingChunked)
-				message.Content = new RequestDataContent(requestData, cancellationToken);
-			else
+			var stream = requestData.MemoryStreamFactory.Create();
+			if (requestData.HttpCompression)
 			{
-				var stream = requestData.MemoryStreamFactory.Create();
-				if (requestData.HttpCompression)
-				{
-					using var zipStream = new GZipStream(stream, CompressionMode.Compress, true);
-					await requestData.PostData.WriteAsync(zipStream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
-				}
-				else
-					await requestData.PostData.WriteAsync(stream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
+				using var zipStream = new GZipStream(stream, CompressionMode.Compress, true);
+				await requestData.PostData.WriteAsync(zipStream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
+			}
+			else
+				await requestData.PostData.WriteAsync(stream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
 
-				// the written bytes are uncompressed, so can only be used when http compression isn't used
-				if (requestData.PostData.DisableDirectStreaming.GetValueOrDefault(false) && !requestData.HttpCompression)
-				{
-					message.Content = new ByteArrayContent(requestData.PostData.WrittenBytes);
+			// the written bytes are uncompressed, so can only be used when http compression isn't used
+			if (requestData.PostData.DisableDirectStreaming.GetValueOrDefault(false) && !requestData.HttpCompression)
+			{
+				message.Content = new ByteArrayContent(requestData.PostData.WrittenBytes);
 #if DOTNETCORE_2_1_OR_HIGHER
-						await stream.DisposeAsync().ConfigureAwait(false);
+					await stream.DisposeAsync().ConfigureAwait(false);
 #else
-					stream.Dispose();
+				stream.Dispose();
 #endif
-				}
-				else
-				{
-					stream.Position = 0;
-					message.Content = new StreamContent(stream);
-				}
+			}
+			else
+			{
+				stream.Position = 0;
+				message.Content = new StreamContent(stream);
+			}
 
-				if (requestData.HttpCompression)
-					message.Content.Headers.ContentEncoding.Add("gzip");
+			if (requestData.HttpCompression)
+				message.Content.Headers.ContentEncoding.Add("gzip");
 
-				message.Content.Headers.ContentType = new MediaTypeHeaderValue(requestData.RequestMimeType);
-			}
+			message.Content.Headers.ContentType = new MediaTypeHeaderValue(requestData.RequestMimeType);
 		}
+	}
 
-		private static System.Net.Http.HttpMethod ConvertHttpMethod(HttpMethod httpMethod)
+	private static System.Net.Http.HttpMethod ConvertHttpMethod(HttpMethod httpMethod)
+	{
+		switch (httpMethod)
 		{
-			switch (httpMethod)
-			{
-				case HttpMethod.GET: return System.Net.Http.HttpMethod.Get;
-				case HttpMethod.POST: return System.Net.Http.HttpMethod.Post;
-				case HttpMethod.PUT: return System.Net.Http.HttpMethod.Put;
-				case HttpMethod.DELETE: return System.Net.Http.HttpMethod.Delete;
-				case HttpMethod.HEAD: return System.Net.Http.HttpMethod.Head;
-				default:
-					throw new ArgumentException("Invalid value for HttpMethod", nameof(httpMethod));
-			}
+			case HttpMethod.GET: return System.Net.Http.HttpMethod.Get;
+			case HttpMethod.POST: return System.Net.Http.HttpMethod.Post;
+			case HttpMethod.PUT: return System.Net.Http.HttpMethod.Put;
+			case HttpMethod.DELETE: return System.Net.Http.HttpMethod.Delete;
+			case HttpMethod.HEAD: return System.Net.Http.HttpMethod.Head;
+			default:
+				throw new ArgumentException("Invalid value for HttpMethod", nameof(httpMethod));
 		}
+	}
 
-		internal static int GetClientKey(RequestData requestData)
+	internal static int GetClientKey(RequestData requestData)
+	{
+		unchecked
 		{
-			unchecked
-			{
-				var hashCode = requestData.RequestTimeout.GetHashCode();
-				hashCode = (hashCode * 397) ^ requestData.HttpCompression.GetHashCode();
-				hashCode = (hashCode * 397) ^ (requestData.ProxyAddress?.GetHashCode() ?? 0);
-				hashCode = (hashCode * 397) ^ (requestData.ProxyUsername?.GetHashCode() ?? 0);
-				hashCode = (hashCode * 397) ^ (requestData.ProxyPassword?.GetHashCode() ?? 0);
-				hashCode = (hashCode * 397) ^ requestData.DisableAutomaticProxyDetection.GetHashCode();
-				return hashCode;
-			}
+			var hashCode = requestData.RequestTimeout.GetHashCode();
+			hashCode = (hashCode * 397) ^ requestData.HttpCompression.GetHashCode();
+			hashCode = (hashCode * 397) ^ (requestData.ProxyAddress?.GetHashCode() ?? 0);
+			hashCode = (hashCode * 397) ^ (requestData.ProxyUsername?.GetHashCode() ?? 0);
+			hashCode = (hashCode * 397) ^ (requestData.ProxyPassword?.GetHashCode() ?? 0);
+			hashCode = (hashCode * 397) ^ requestData.DisableAutomaticProxyDetection.GetHashCode();
+			return hashCode;
 		}
-
-		/// <summary> Allows subclasses to hook into the parents dispose </summary>
-		protected virtual void DisposeManagedResources() => HttpClientFactory.Dispose();
 	}
+
+	/// <inheritdoc />
+	protected override void DisposeManagedResources() => HttpClientFactory.Dispose();
 }
 #endif
diff --git a/src/Elastic.Transport/Components/TransportClient/HttpWebRequestTransportClient.cs b/src/Elastic.Transport/Components/TransportClient/HttpWebRequestTransportClient.cs
index 899bb75..90a8b0e 100644
--- a/src/Elastic.Transport/Components/TransportClient/HttpWebRequestTransportClient.cs
+++ b/src/Elastic.Transport/Components/TransportClient/HttpWebRequestTransportClient.cs
@@ -16,65 +16,141 @@
 using Elastic.Transport.Diagnostics;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// This provides an <see cref="ITransportClient"/> implementation that targets <see cref="HttpWebRequest"/>.
-	/// <para>
-	/// On .NET full framework <see cref="HttpTransportClient"/> is an alias to this.
-	/// </para>
-	/// <para/>
-	/// <para>Do NOT use this class directly on .NET Core. <see cref="HttpWebRequest"/> is monkey patched
-	/// over HttpClient and does not reuse its instances of HttpClient
-	/// </para>
-	/// </summary>
+namespace Elastic.Transport;
+
+/// <summary>
+/// This provides an <see cref="TransportClient"/> implementation that targets <see cref="HttpWebRequest"/>.
+/// <para>
+/// On .NET full framework <see cref="HttpTransportClient"/> is an alias to this.
+/// </para>
+/// <para/>
+/// <para>Do NOT use this class directly on .NET Core. <see cref="HttpWebRequest"/> is monkey patched
+/// over HttpClient and does not reuse its instances of HttpClient
+/// </para>
+/// </summary>
 #if DOTNETCORE
-	[Obsolete("CoreFX HttpWebRequest uses HttpClient under the covers but does not reuse HttpClient instances, do NOT use on .NET core only used as the default on Full Framework")]
+[Obsolete("CoreFX HttpWebRequest uses HttpClient under the covers but does not reuse HttpClient instances, do NOT use on .NET core only used as the default on Full Framework")]
 #endif
-	public class HttpWebRequestTransportClient : ITransportClient
+public class HttpWebRequestTransportClient : TransportClient
+{
+	private string _expectedCertificateFingerprint;
+
+	static HttpWebRequestTransportClient()
 	{
-		private string _expectedCertificateFingerprint;
+		//Not available under mono
+		if (!IsMono) HttpWebRequest.DefaultMaximumErrorResponseLength = -1;
+	}
+
+	internal HttpWebRequestTransportClient() { }
+
+	internal static bool IsMono { get; } = Type.GetType("Mono.Runtime") != null;
 
-		static HttpWebRequestTransportClient()
+	/// <inheritdoc cref="TransportClient.Request{TResponse}"/>>
+	public override TResponse Request<TResponse>(RequestData requestData)
+	{
+		int? statusCode = null;
+		Stream responseStream = null;
+		Exception ex = null;
+		string mimeType = null;
+		long contentLength = -1;
+		ReadOnlyDictionary<TcpState, int> tcpStats = null;
+		ReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats = null;
+		Dictionary<string, IEnumerable<string>> responseHeaders = null;
+
+		try
 		{
-			//Not available under mono
-			if (!IsMono) HttpWebRequest.DefaultMaximumErrorResponseLength = -1;
+			var request = CreateHttpWebRequest(requestData);
+			var data = requestData.PostData;
+
+			if (data != null)
+			{
+				using (var stream = request.GetRequestStream())
+				{
+					if (requestData.HttpCompression)
+					{
+						using var zipStream = new GZipStream(stream, CompressionMode.Compress);
+						data.Write(zipStream, requestData.ConnectionSettings);
+					}
+					else
+						data.Write(stream, requestData.ConnectionSettings);
+				}
+			}
+			requestData.MadeItToResponse = true;
+
+			if (requestData.TcpStats)
+				tcpStats = TcpStats.GetStates();
+
+			if (requestData.ThreadPoolStats)
+				threadPoolStats = ThreadPoolStats.GetStats();
+
+			//http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx
+			//Either the stream or the response object needs to be closed but not both although it won't
+			//throw any errors if both are closed atleast one of them has to be Closed.
+			//Since we expose the stream we let closing the stream determining when to close the connection
+			var httpWebResponse = (HttpWebResponse)request.GetResponse();
+			HandleResponse(httpWebResponse, out statusCode, out responseStream, out mimeType);
+			responseHeaders = ParseHeaders(requestData, httpWebResponse, responseHeaders);
+			contentLength = httpWebResponse.ContentLength;
+		}
+		catch (WebException e)
+		{
+			ex = e;
+			if (e.Response is HttpWebResponse httpWebResponse)
+				HandleResponse(httpWebResponse, out statusCode, out responseStream, out mimeType);
 		}
 
-		internal static bool IsMono { get; } = Type.GetType("Mono.Runtime") != null;
+		responseStream ??= Stream.Null;
+		var response = requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponse<TResponse>(requestData, ex, statusCode, responseHeaders, responseStream, mimeType, contentLength, threadPoolStats, tcpStats);
+		return response;
+	}
 
-		/// <inheritdoc cref="ITransportClient.Request{TResponse}"/>>
-		public virtual TResponse Request<TResponse>(RequestData requestData)
-			where TResponse : class, ITransportResponse, new()
+	/// <inheritdoc cref="TransportClient.RequestAsync{TResponse}"/>>
+	public override async Task<TResponse> RequestAsync<TResponse>(RequestData requestData,
+		CancellationToken cancellationToken)
+	{
+		Action unregisterWaitHandle = null;
+		int? statusCode = null;
+		Stream responseStream = null;
+		Exception ex = null;
+		string mimeType = null;
+		long contentLength = -1;
+		ReadOnlyDictionary<TcpState, int> tcpStats = null;
+		ReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats = null;
+		Dictionary<string, IEnumerable<string>> responseHeaders = null;
+		requestData.IsAsync = true;
+
+		try
 		{
-			int? statusCode = null;
-			Stream responseStream = null;
-			Exception ex = null;
-			string mimeType = null;
-			long contentLength = -1;
-			ReadOnlyDictionary<TcpState, int> tcpStats = null;
-			ReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats = null;
-			Dictionary<string, IEnumerable<string>> responseHeaders = null;
-
-			try
+			var data = requestData.PostData;
+			var request = CreateHttpWebRequest(requestData);
+			using (cancellationToken.Register(() => request.Abort()))
 			{
-				var request = CreateHttpWebRequest(requestData);
-				var data = requestData.PostData;
-
 				if (data != null)
 				{
-					using (var stream = request.GetRequestStream())
+					var apmGetRequestStreamTask =
+						Task.Factory.FromAsync(request.BeginGetRequestStream, r => request.EndGetRequestStream(r), null);
+					unregisterWaitHandle = RegisterApmTaskTimeout(apmGetRequestStreamTask, request, requestData);
+
+					using (var stream = await apmGetRequestStreamTask.ConfigureAwait(false))
 					{
 						if (requestData.HttpCompression)
 						{
 							using var zipStream = new GZipStream(stream, CompressionMode.Compress);
-							data.Write(zipStream, requestData.ConnectionSettings);
+							await data.WriteAsync(zipStream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
 						}
 						else
-							data.Write(stream, requestData.ConnectionSettings);
+							await data.WriteAsync(stream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
 					}
+					unregisterWaitHandle?.Invoke();
 				}
 				requestData.MadeItToResponse = true;
+				//http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx
+				//Either the stream or the response object needs to be closed but not both although it won't
+				//throw any errors if both are closed atleast one of them has to be Closed.
+				//Since we expose the stream we let closing the stream determining when to close the connection
+
+				var apmGetResponseTask = Task.Factory.FromAsync(request.BeginGetResponse, r => request.EndGetResponse(r), null);
+				unregisterWaitHandle = RegisterApmTaskTimeout(apmGetResponseTask, request, requestData);
 
 				if (requestData.TcpStats)
 					tcpStats = TcpStats.GetStates();
@@ -82,369 +158,286 @@ public virtual TResponse Request<TResponse>(RequestData requestData)
 				if (requestData.ThreadPoolStats)
 					threadPoolStats = ThreadPoolStats.GetStats();
 
-				//http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx
-				//Either the stream or the response object needs to be closed but not both although it won't
-				//throw any errors if both are closed atleast one of them has to be Closed.
-				//Since we expose the stream we let closing the stream determining when to close the connection
-				var httpWebResponse = (HttpWebResponse)request.GetResponse();
+				var httpWebResponse = (HttpWebResponse)await apmGetResponseTask.ConfigureAwait(false);
 				HandleResponse(httpWebResponse, out statusCode, out responseStream, out mimeType);
 				responseHeaders = ParseHeaders(requestData, httpWebResponse, responseHeaders);
 				contentLength = httpWebResponse.ContentLength;
 			}
-			catch (WebException e)
-			{
-				ex = e;
-				if (e.Response is HttpWebResponse httpWebResponse)
-					HandleResponse(httpWebResponse, out statusCode, out responseStream, out mimeType);
-			}
-
-			responseStream ??= Stream.Null;
-			var response = requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponse<TResponse>(requestData, ex, statusCode, responseHeaders, responseStream, mimeType, contentLength, threadPoolStats, tcpStats);
-			return response;
 		}
-
-		/// <inheritdoc cref="ITransportClient.RequestAsync{TResponse}"/>>
-		public virtual async Task<TResponse> RequestAsync<TResponse>(RequestData requestData,
-			CancellationToken cancellationToken
-		)
-			where TResponse : class, ITransportResponse, new()
+		catch (WebException e)
 		{
-			Action unregisterWaitHandle = null;
-			int? statusCode = null;
-			Stream responseStream = null;
-			Exception ex = null;
-			string mimeType = null;
-			long contentLength = -1;
-			ReadOnlyDictionary<TcpState, int> tcpStats = null;
-			ReadOnlyDictionary<string, ThreadPoolStatistics> threadPoolStats = null;
-			Dictionary<string, IEnumerable<string>> responseHeaders = null;
-			requestData.IsAsync = true;
-
-			try
-			{
-				var data = requestData.PostData;
-				var request = CreateHttpWebRequest(requestData);
-				using (cancellationToken.Register(() => request.Abort()))
-				{
-					if (data != null)
-					{
-						var apmGetRequestStreamTask =
-							Task.Factory.FromAsync(request.BeginGetRequestStream, r => request.EndGetRequestStream(r), null);
-						unregisterWaitHandle = RegisterApmTaskTimeout(apmGetRequestStreamTask, request, requestData);
-
-						using (var stream = await apmGetRequestStreamTask.ConfigureAwait(false))
-						{
-							if (requestData.HttpCompression)
-							{
-								using var zipStream = new GZipStream(stream, CompressionMode.Compress);
-								await data.WriteAsync(zipStream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
-							}
-							else
-								await data.WriteAsync(stream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
-						}
-						unregisterWaitHandle?.Invoke();
-					}
-					requestData.MadeItToResponse = true;
-					//http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx
-					//Either the stream or the response object needs to be closed but not both although it won't
-					//throw any errors if both are closed atleast one of them has to be Closed.
-					//Since we expose the stream we let closing the stream determining when to close the connection
-
-					var apmGetResponseTask = Task.Factory.FromAsync(request.BeginGetResponse, r => request.EndGetResponse(r), null);
-					unregisterWaitHandle = RegisterApmTaskTimeout(apmGetResponseTask, request, requestData);
-
-					if (requestData.TcpStats)
-						tcpStats = TcpStats.GetStates();
+			ex = e;
+			if (e.Response is HttpWebResponse httpWebResponse)
+				HandleResponse(httpWebResponse, out statusCode, out responseStream, out mimeType);
+		}
+		finally
+		{
+			unregisterWaitHandle?.Invoke();
+		}
+		responseStream ??= Stream.Null;
+		var response = await requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponseAsync<TResponse>
+				(requestData, ex, statusCode, responseHeaders, responseStream, mimeType, contentLength, threadPoolStats, tcpStats, cancellationToken)
+			.ConfigureAwait(false);
+		return response;
+	}
 
-					if (requestData.ThreadPoolStats)
-						threadPoolStats = ThreadPoolStats.GetStats();
+	private static Dictionary<string, IEnumerable<string>> ParseHeaders(RequestData requestData, HttpWebResponse responseMessage, Dictionary<string, IEnumerable<string>> responseHeaders)
+	{
+		if (!responseMessage.SupportsHeaders && !responseMessage.Headers.HasKeys()) return null;
 
-					var httpWebResponse = (HttpWebResponse)await apmGetResponseTask.ConfigureAwait(false);
-					HandleResponse(httpWebResponse, out statusCode, out responseStream, out mimeType);
-					responseHeaders = ParseHeaders(requestData, httpWebResponse, responseHeaders);
-					contentLength = httpWebResponse.ContentLength;
-				}
-			}
-			catch (WebException e)
-			{
-				ex = e;
-				if (e.Response is HttpWebResponse httpWebResponse)
-					HandleResponse(httpWebResponse, out statusCode, out responseStream, out mimeType);
-			}
-			finally
+		if (requestData.ParseAllHeaders)
+		{
+			foreach (var key in responseMessage.Headers.AllKeys)
 			{
-				unregisterWaitHandle?.Invoke();
+				responseHeaders ??= new Dictionary<string, IEnumerable<string>>();
+				responseHeaders.Add(key, responseMessage.Headers.GetValues(key));
 			}
-			responseStream ??= Stream.Null;
-			var response = await requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponseAsync<TResponse>
-					(requestData, ex, statusCode, responseHeaders, responseStream, mimeType, contentLength, threadPoolStats, tcpStats, cancellationToken)
-				.ConfigureAwait(false);
-			return response;
 		}
-
-		private static Dictionary<string, IEnumerable<string>> ParseHeaders(RequestData requestData, HttpWebResponse responseMessage, Dictionary<string, IEnumerable<string>> responseHeaders)
+		else if (requestData.ResponseHeadersToParse.Count > 0)
 		{
-			if (!responseMessage.SupportsHeaders && !responseMessage.Headers.HasKeys()) return null;
-
-			if (requestData.ParseAllHeaders)
+			foreach (var headerToParse in requestData.ResponseHeadersToParse)
 			{
-				foreach (var key in responseMessage.Headers.AllKeys)
+				if (responseMessage.Headers.AllKeys.Contains(headerToParse, StringComparer.OrdinalIgnoreCase))
 				{
 					responseHeaders ??= new Dictionary<string, IEnumerable<string>>();
-					responseHeaders.Add(key, responseMessage.Headers.GetValues(key));
-				}
-			}
-			else if (requestData.ResponseHeadersToParse.Count > 0)
-			{
-				foreach (var headerToParse in requestData.ResponseHeadersToParse)
-				{
-					if (responseMessage.Headers.AllKeys.Contains(headerToParse, StringComparer.OrdinalIgnoreCase))
-					{
-						responseHeaders ??= new Dictionary<string, IEnumerable<string>>();
-						responseHeaders.Add(headerToParse, responseMessage.Headers.GetValues(headerToParse));
-					}
+					responseHeaders.Add(headerToParse, responseMessage.Headers.GetValues(headerToParse));
 				}
 			}
-
-			return responseHeaders;
 		}
 
-		void IDisposable.Dispose() => DisposeManagedResources();
+		return responseHeaders;
+	}
+
+	/// <summary>
+	/// Allows subclasses to modify the <see cref="HttpWebRequest"/> instance that is going to be used for the API call
+	/// </summary>
+	/// <param name="requestData">An instance of <see cref="RequestData"/> describing where and how to call out to</param>
+	internal HttpWebRequest CreateHttpWebRequest(RequestData requestData)
+	{
+		var request = CreateWebRequest(requestData);
+		SetAuthenticationIfNeeded(requestData, request);
+		SetProxyIfNeeded(request, requestData);
+		SetServerCertificateValidationCallBackIfNeeded(request, requestData);
+		SetClientCertificates(request, requestData);
+		AlterServicePoint(request.ServicePoint, requestData);
+		return request;
+	}
+
+	/// <summary> Hook for subclasses to set additional client certificates on <paramref name="request"/> </summary>
+	internal void SetClientCertificates(HttpWebRequest request, RequestData requestData)
+	{
+		if (requestData.ClientCertificates != null)
+			request.ClientCertificates.AddRange(requestData.ClientCertificates);
+	}
 
-		/// <summary>
-		/// Allows subclasses to modify the <see cref="HttpWebRequest"/> instance that is going to be used for the API call
-		/// </summary>
-		/// <param name="requestData">An instance of <see cref="RequestData"/> describing where and how to call out to</param>
-		protected virtual HttpWebRequest CreateHttpWebRequest(RequestData requestData)
+	private string ComparableFingerprint(string fingerprint)
+	{
+		var finalFingerprint = fingerprint;
+		if (fingerprint.Contains(':'))
 		{
-			var request = CreateWebRequest(requestData);
-			SetAuthenticationIfNeeded(requestData, request);
-			SetProxyIfNeeded(request, requestData);
-			SetServerCertificateValidationCallBackIfNeeded(request, requestData);
-			SetClientCertificates(request, requestData);
-			AlterServicePoint(request.ServicePoint, requestData);
-			return request;
+			finalFingerprint = fingerprint.Replace(":", string.Empty);
 		}
-
-		/// <summary> Hook for subclasses to set additional client certificates on <paramref name="request"/> </summary>
-		protected virtual void SetClientCertificates(HttpWebRequest request, RequestData requestData)
+		else if (fingerprint.Contains('-'))
 		{
-			if (requestData.ClientCertificates != null)
-				request.ClientCertificates.AddRange(requestData.ClientCertificates);
+			finalFingerprint = fingerprint.Replace("-", string.Empty);
 		}
+		return finalFingerprint;
+	}
 
-		private string ComparableFingerprint(string fingerprint)
+	/// <summary> Hook for subclasses override the certificate validation on <paramref name="request"/> </summary>
+	internal void SetServerCertificateValidationCallBackIfNeeded(HttpWebRequest request, RequestData requestData)
+	{
+		var callback = requestData?.ConnectionSettings?.ServerCertificateValidationCallback;
+#if !__MonoCS__
+		//Only assign if one is defined on connection settings and a subclass has not already set one
+		if (callback != null && request.ServerCertificateValidationCallback == null)
 		{
-			var finalFingerprint = fingerprint;
-			if (fingerprint.Contains(':'))
-			{
-				finalFingerprint = fingerprint.Replace(":", string.Empty);
-			}
-			else if (fingerprint.Contains('-'))
-			{
-				finalFingerprint = fingerprint.Replace("-", string.Empty);
-			}
-			return finalFingerprint;
+			request.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(callback);
 		}
-
-		/// <summary> Hook for subclasses override the certificate validation on <paramref name="request"/> </summary>
-		protected virtual void SetServerCertificateValidationCallBackIfNeeded(HttpWebRequest request, RequestData requestData)
+		else if (!string.IsNullOrEmpty(requestData.ConnectionSettings.CertificateFingerprint))
 		{
-			var callback = requestData?.ConnectionSettings?.ServerCertificateValidationCallback;
-#if !__MonoCS__
-			//Only assign if one is defined on connection settings and a subclass has not already set one
-			if (callback != null && request.ServerCertificateValidationCallback == null)
+			request.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback((request, certificate, chain, policyErrors) =>
 			{
-				request.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback(callback);
-			}
-			else if (!string.IsNullOrEmpty(requestData.ConnectionSettings.CertificateFingerprint))
-			{
-				request.ServerCertificateValidationCallback = new RemoteCertificateValidationCallback((request, certificate, chain, policyErrors) =>
-				{
-					if (certificate is null && chain is null) return false;
+				if (certificate is null && chain is null) return false;
 
-					// The "cleaned", expected fingerprint is cached to avoid repeated cost of converting it to a comparable form.
-					_expectedCertificateFingerprint  ??= CertificateHelpers.ComparableFingerprint(requestData.ConnectionSettings.CertificateFingerprint);
+				// The "cleaned", expected fingerprint is cached to avoid repeated cost of converting it to a comparable form.
+				_expectedCertificateFingerprint  ??= CertificateHelpers.ComparableFingerprint(requestData.ConnectionSettings.CertificateFingerprint);
 
-					// If there is a chain, check each certificate up to the root
-					if (chain is not null)
+				// If there is a chain, check each certificate up to the root
+				if (chain is not null)
+				{
+					foreach (var element in chain.ChainElements)
 					{
-						foreach (var element in chain.ChainElements)
-						{
-							if (CertificateHelpers.ValidateCertificateFingerprint(element.Certificate, _expectedCertificateFingerprint))
-								return true;
-						}
+						if (CertificateHelpers.ValidateCertificateFingerprint(element.Certificate, _expectedCertificateFingerprint))
+							return true;
 					}
+				}
 
-					// Otherwise, check the certificate
-					return CertificateHelpers.ValidateCertificateFingerprint(certificate, _expectedCertificateFingerprint);
-				});
-			}
+				// Otherwise, check the certificate
+				return CertificateHelpers.ValidateCertificateFingerprint(certificate, _expectedCertificateFingerprint);
+			});
+		}
 #else
-			if (callback != null)
-				throw new Exception("Mono misses ServerCertificateValidationCallback on HttpWebRequest");
+		if (callback != null)
+			throw new Exception("Mono misses ServerCertificateValidationCallback on HttpWebRequest");
 #endif
-		}
+	}
 
-		private static HttpWebRequest CreateWebRequest(RequestData requestData)
-		{
-			var request = (HttpWebRequest)WebRequest.Create(requestData.Uri);
+	private static HttpWebRequest CreateWebRequest(RequestData requestData)
+	{
+		var request = (HttpWebRequest)WebRequest.Create(requestData.Uri);
 
-			request.Accept = requestData.Accept;
-			request.ContentType = requestData.RequestMimeType;
+		request.Accept = requestData.Accept;
+		request.ContentType = requestData.RequestMimeType;
 #if !DOTNETCORE
-			// on netstandard/netcoreapp2.0 this throws argument exception
-			request.MaximumResponseHeadersLength = -1;
+		// on netstandard/netcoreapp2.0 this throws argument exception
+		request.MaximumResponseHeadersLength = -1;
 #endif
-			request.Pipelined = requestData.Pipelined;
+		request.Pipelined = requestData.Pipelined;
 
-			if (requestData.TransferEncodingChunked)
-				request.SendChunked = true;
+		if (requestData.TransferEncodingChunked)
+			request.SendChunked = true;
 
-			if (requestData.HttpCompression)
-			{
-				request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
-				request.Headers.Add("Accept-Encoding", "gzip,deflate");
-				request.Headers.Add("Content-Encoding", "gzip");
-			}
+		if (requestData.HttpCompression)
+		{
+			request.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+			request.Headers.Add("Accept-Encoding", "gzip,deflate");
+			request.Headers.Add("Content-Encoding", "gzip");
+		}
 
-			var userAgent = requestData.UserAgent?.ToString();
-			if (!string.IsNullOrWhiteSpace(userAgent))
-				request.UserAgent = userAgent;
+		var userAgent = requestData.UserAgent?.ToString();
+		if (!string.IsNullOrWhiteSpace(userAgent))
+			request.UserAgent = userAgent;
 
-			if (!string.IsNullOrWhiteSpace(requestData.RunAs))
-				request.Headers.Add(RequestData.RunAsSecurityHeader, requestData.RunAs);
+		if (!string.IsNullOrWhiteSpace(requestData.RunAs))
+			request.Headers.Add(RequestData.RunAsSecurityHeader, requestData.RunAs);
 
-			if (requestData.Headers != null && requestData.Headers.HasKeys())
-				request.Headers.Add(requestData.Headers);
+		if (requestData.Headers != null && requestData.Headers.HasKeys())
+			request.Headers.Add(requestData.Headers);
 
-			if (requestData.MetaHeaderProvider is object)
-			{
-				var value = requestData.MetaHeaderProvider.ProduceHeaderValue(requestData);
+		if (requestData.MetaHeaderProvider is object)
+		{
+			var value = requestData.MetaHeaderProvider.ProduceHeaderValue(requestData);
 
-				if (!string.IsNullOrEmpty(value))
-					request.Headers.Add(requestData.MetaHeaderProvider.HeaderName, requestData.MetaHeaderProvider.ProduceHeaderValue(requestData));
-			}
+			if (!string.IsNullOrEmpty(value))
+				request.Headers.Add(requestData.MetaHeaderProvider.HeaderName, requestData.MetaHeaderProvider.ProduceHeaderValue(requestData));
+		}
 
-			var timeout = (int)requestData.RequestTimeout.TotalMilliseconds;
-			request.Timeout = timeout;
-			request.ReadWriteTimeout = timeout;
+		var timeout = (int)requestData.RequestTimeout.TotalMilliseconds;
+		request.Timeout = timeout;
+		request.ReadWriteTimeout = timeout;
 
-			//WebRequest won't send Content-Length: 0 for empty bodies
-			//which goes against RFC's and might break i.e IIS when used as a proxy.
-			//see: https://github.com/elastic/elasticsearch-net/issues/562
-			var m = requestData.Method.GetStringValue();
-			request.Method = m;
-			if (m != "HEAD" && m != "GET" && requestData.PostData == null)
-				request.ContentLength = 0;
+		//WebRequest won't send Content-Length: 0 for empty bodies
+		//which goes against RFC's and might break i.e IIS when used as a proxy.
+		//see: https://github.com/elastic/elasticsearch-net/issues/562
+		var m = requestData.Method.GetStringValue();
+		request.Method = m;
+		if (m != "HEAD" && m != "GET" && requestData.PostData == null)
+			request.ContentLength = 0;
 
-			return request;
-		}
+		return request;
+	}
 
-		/// <summary> Hook for subclasses override <see cref="ServicePoint"/> behavior</summary>
-		protected virtual void AlterServicePoint(ServicePoint requestServicePoint, RequestData requestData)
-		{
-			requestServicePoint.UseNagleAlgorithm = false;
-			requestServicePoint.Expect100Continue = false;
-			requestServicePoint.ConnectionLeaseTimeout = (int)requestData.DnsRefreshTimeout.TotalMilliseconds;
-			if (requestData.ConnectionSettings.ConnectionLimit > 0)
-				requestServicePoint.ConnectionLimit = requestData.ConnectionSettings.ConnectionLimit;
-			//looking at http://referencesource.microsoft.com/#System/net/System/Net/ServicePoint.cs
-			//this method only sets internal values and wont actually cause timers and such to be reset
-			//So it should be idempotent if called with the same parameters
-			requestServicePoint.SetTcpKeepAlive(true, requestData.KeepAliveTime, requestData.KeepAliveInterval);
-		}
+	/// <summary> Hook for subclasses override <see cref="ServicePoint"/> behavior</summary>
+	internal void AlterServicePoint(ServicePoint requestServicePoint, RequestData requestData)
+	{
+		requestServicePoint.UseNagleAlgorithm = false;
+		requestServicePoint.Expect100Continue = false;
+		requestServicePoint.ConnectionLeaseTimeout = (int)requestData.DnsRefreshTimeout.TotalMilliseconds;
+		if (requestData.ConnectionSettings.ConnectionLimit > 0)
+			requestServicePoint.ConnectionLimit = requestData.ConnectionSettings.ConnectionLimit;
+		//looking at http://referencesource.microsoft.com/#System/net/System/Net/ServicePoint.cs
+		//this method only sets internal values and wont actually cause timers and such to be reset
+		//So it should be idempotent if called with the same parameters
+		requestServicePoint.SetTcpKeepAlive(true, requestData.KeepAliveTime, requestData.KeepAliveInterval);
+	}
 
-		/// <summary> Hook for subclasses to set proxy on <paramref name="request"/> </summary>
-		protected virtual void SetProxyIfNeeded(HttpWebRequest request, RequestData requestData)
+	/// <summary> Hook for subclasses to set proxy on <paramref name="request"/> </summary>
+	internal void SetProxyIfNeeded(HttpWebRequest request, RequestData requestData)
+	{
+		if (!string.IsNullOrWhiteSpace(requestData.ProxyAddress))
 		{
-			if (!string.IsNullOrWhiteSpace(requestData.ProxyAddress))
-			{
-				var uri = new Uri(requestData.ProxyAddress);
-				var proxy = new WebProxy(uri);
-				var credentials = new NetworkCredential(requestData.ProxyUsername, requestData.ProxyPassword);
-				proxy.Credentials = credentials;
-				request.Proxy = proxy;
-			}
-
-			if (requestData.DisableAutomaticProxyDetection)
-				request.Proxy = null!;
+			var uri = new Uri(requestData.ProxyAddress);
+			var proxy = new WebProxy(uri);
+			var credentials = new NetworkCredential(requestData.ProxyUsername, requestData.ProxyPassword);
+			proxy.Credentials = credentials;
+			request.Proxy = proxy;
 		}
 
-		/// <summary> Hook for subclasses to set authentication on <paramref name="request"/></summary>
-		protected virtual void SetAuthenticationIfNeeded(RequestData requestData, HttpWebRequest request)
-		{
-			//If user manually specifies an Authorization Header give it preference
-			if (requestData.Headers.HasKeys() && requestData.Headers.AllKeys.Contains("Authorization"))
-			{
-				var header = requestData.Headers["Authorization"];
-				request.Headers["Authorization"] = header;
-				return;
-			}
-			SetBasicAuthenticationIfNeeded(request, requestData);
-		}
+		if (requestData.DisableAutomaticProxyDetection)
+			request.Proxy = null!;
+	}
 
-		private static void SetBasicAuthenticationIfNeeded(HttpWebRequest request, RequestData requestData)
+	/// <summary> Hook for subclasses to set authentication on <paramref name="request"/></summary>
+	internal void SetAuthenticationIfNeeded(RequestData requestData, HttpWebRequest request)
+	{
+		//If user manually specifies an Authorization Header give it preference
+		if (requestData.Headers.HasKeys() && requestData.Headers.AllKeys.Contains("Authorization"))
 		{
-			// Basic auth credentials take the following precedence (highest -> lowest):
-			// 1 - Specified on the request (highest precedence)
-			// 2 - Specified at the global ITransportClientSettings level
-			// 3 - Specified with the URI (lowest precedence)
-
+			var header = requestData.Headers["Authorization"];
+			request.Headers["Authorization"] = header;
+			return;
+		}
+		SetBasicAuthenticationIfNeeded(request, requestData);
+	}
 
-			// Basic auth credentials take the following precedence (highest -> lowest):
-			// 1 - Specified with the URI (highest precedence)
-			// 2 - Specified on the request
-			// 3 - Specified at the global ITransportClientSettings level (lowest precedence)
+	private static void SetBasicAuthenticationIfNeeded(HttpWebRequest request, RequestData requestData)
+	{
+		// Basic auth credentials take the following precedence (highest -> lowest):
+		// 1 - Specified on the request (highest precedence)
+		// 2 - Specified at the global TransportClientSettings level
+		// 3 - Specified with the URI (lowest precedence)
 
-			string parameters = null;
-			string scheme = null;
-			if (!requestData.Uri.UserInfo.IsNullOrEmpty())
-			{
-				parameters = BasicAuthentication.GetBase64String(Uri.UnescapeDataString(requestData.Uri.UserInfo));
-				scheme = BasicAuthentication.BasicAuthenticationScheme;
-			}
-			else if (requestData.AuthenticationHeader != null && requestData.AuthenticationHeader.TryGetAuthorizationParameters(out var v))
-			{
-				parameters = v;
-				scheme = requestData.AuthenticationHeader.AuthScheme;
-			}
 
-			if (parameters.IsNullOrEmpty()) return;
+		// Basic auth credentials take the following precedence (highest -> lowest):
+		// 1 - Specified with the URI (highest precedence)
+		// 2 - Specified on the request
+		// 3 - Specified at the global TransportClientSettings level (lowest precedence)
 
-			request.Headers["Authorization"] = $"{scheme} {parameters}";
+		string parameters = null;
+		string scheme = null;
+		if (!requestData.Uri.UserInfo.IsNullOrEmpty())
+		{
+			parameters = BasicAuthentication.GetBase64String(Uri.UnescapeDataString(requestData.Uri.UserInfo));
+			scheme = BasicAuthentication.BasicAuthenticationScheme;
 		}
-
-		/// <summary>
-		/// Registers an APM async task cancellation on the threadpool
-		/// </summary>
-		/// <returns>An unregister action that can be used to remove the waithandle prematurely</returns>
-		private static Action RegisterApmTaskTimeout(IAsyncResult result, WebRequest request, RequestData requestData)
+		else if (requestData.AuthenticationHeader != null && requestData.AuthenticationHeader.TryGetAuthorizationParameters(out var v))
 		{
-			var waitHandle = result.AsyncWaitHandle;
-			var registeredWaitHandle =
-				ThreadPool.RegisterWaitForSingleObject(waitHandle, TimeoutCallback, request, requestData.RequestTimeout, true);
-			return () => registeredWaitHandle.Unregister(waitHandle);
+			parameters = v;
+			scheme = requestData.AuthenticationHeader.AuthScheme;
 		}
 
-		private static void TimeoutCallback(object state, bool timedOut)
-		{
-			if (!timedOut) return;
+		if (parameters.IsNullOrEmpty()) return;
 
-			(state as WebRequest)?.Abort();
-		}
+		request.Headers["Authorization"] = $"{scheme} {parameters}";
+	}
 
-		private static void HandleResponse(HttpWebResponse response, out int? statusCode, out Stream responseStream, out string mimeType)
-		{
-			statusCode = (int)response.StatusCode;
-			responseStream = response.GetResponseStream();
-			mimeType = response.ContentType;
-			// https://github.com/elastic/elasticsearch-net/issues/2311
-			// if stream is null call dispose on response instead.
-			if (responseStream == null || responseStream == Stream.Null) response.Dispose();
-		}
+	/// <summary>
+	/// Registers an APM async task cancellation on the threadpool
+	/// </summary>
+	/// <returns>An unregister action that can be used to remove the waithandle prematurely</returns>
+	private static Action RegisterApmTaskTimeout(IAsyncResult result, WebRequest request, RequestData requestData)
+	{
+		var waitHandle = result.AsyncWaitHandle;
+		var registeredWaitHandle =
+			ThreadPool.RegisterWaitForSingleObject(waitHandle, TimeoutCallback, request, requestData.RequestTimeout, true);
+		return () => registeredWaitHandle.Unregister(waitHandle);
+	}
 
-		/// <summary> Allows subclasses to hook into the parents dispose </summary>
-		protected virtual void DisposeManagedResources() { }
+	private static void TimeoutCallback(object state, bool timedOut)
+	{
+		if (!timedOut) return;
+
+		(state as WebRequest)?.Abort();
+	}
+
+	private static void HandleResponse(HttpWebResponse response, out int? statusCode, out Stream responseStream, out string mimeType)
+	{
+		statusCode = (int)response.StatusCode;
+		responseStream = response.GetResponseStream();
+		mimeType = response.ContentType;
+		// https://github.com/elastic/elasticsearch-net/issues/2311
+		// if stream is null call dispose on response instead.
+		if (responseStream == null || responseStream == Stream.Null) response.Dispose();
 	}
 }
diff --git a/src/Elastic.Transport/Components/TransportClient/ITransportClient.cs b/src/Elastic.Transport/Components/TransportClient/ITransportClient.cs
deleted file mode 100644
index 8140531..0000000
--- a/src/Elastic.Transport/Components/TransportClient/ITransportClient.cs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// This interface abstracts the actual IO <see cref="ITransport{TConnectionSettings}"/> performs.
-	/// <para><see cref="ITransport{TConnectionSettings}"/> holds a single instance of this class</para>
-	/// <para>The instance to be used is provided to the constructor of <see cref="ITransportConfiguration"/> implementations</para>
-	/// <para>Where its exposed under <see cref="ITransportConfiguration.Connection"/></para>
-	/// </summary>
-	public interface ITransportClient : IDisposable
-	{
-		/// <summary>
-		/// Perform a request to the endpoint described by <paramref name="requestData"/> using its associated configuration.
-		/// </summary>
-		/// <param name="requestData">An object describing where and how to perform the IO call</param>
-		/// <param name="cancellationToken"></param>
-		/// <typeparam name="TResponse">
-		/// An implementation of <see cref="ITransportResponse"/> ensuring enough information is available
-		/// for <see cref="IRequestPipeline"/> and <see cref="ITransport{TConnectionSettings}"/> to determine what to
-		/// do with the response
-		/// </typeparam>
-		/// <returns>
-		/// An implementation of <see cref="ITransportResponse"/> ensuring enough information is available
-		/// for <see cref="IRequestPipeline"/> and <see cref="ITransport{TConnectionSettings}"/> to determine what to
-		/// do with the response
-		/// </returns>
-		Task<TResponse> RequestAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken)
-			where TResponse : class, ITransportResponse, new();
-
-		/// <summary>
-		/// Perform a request to the endpoint described by <paramref name="requestData"/> using its associated configuration.
-		/// </summary>
-		/// <param name="requestData">An object describing where and how to perform the IO call</param>
-		/// <typeparam name="TResponse">
-		/// An implementation of <see cref="ITransportResponse"/> ensuring enough information is available
-		/// for <see cref="IRequestPipeline"/> and <see cref="ITransport{TConnectionSettings}"/> to determine what to
-		/// do with the response
-		/// </typeparam>
-		/// <returns>
-		/// An implementation of <see cref="ITransportResponse"/> ensuring enough information is available
-		/// for <see cref="IRequestPipeline"/> and <see cref="ITransport{TConnectionSettings}"/> to determine what to
-		/// do with the response
-		/// </returns>
-		TResponse Request<TResponse>(RequestData requestData)
-			where TResponse : class, ITransportResponse, new();
-	}
-}
diff --git a/src/Elastic.Transport/Components/TransportClient/InMemoryTransportClient.cs b/src/Elastic.Transport/Components/TransportClient/InMemoryTransportClient.cs
index c747c45..51ea01a 100644
--- a/src/Elastic.Transport/Components/TransportClient/InMemoryTransportClient.cs
+++ b/src/Elastic.Transport/Components/TransportClient/InMemoryTransportClient.cs
@@ -10,112 +10,104 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// An implementation of <see cref="TransportClient"/> designed to not actually do any IO and services requests from an in memory byte buffer
+/// </summary>
+public class InMemoryConnection : TransportClient
 {
+	private static readonly byte[] EmptyBody = Encoding.UTF8.GetBytes("");
+	private readonly string _contentType;
+	private readonly Exception _exception;
+	private readonly byte[] _responseBody;
+	private readonly int _statusCode;
+	private readonly Dictionary<string, IEnumerable<string>> _headers;
+
 	/// <summary>
-	/// An implementation of <see cref="ITransportClient"/> designed to not actually do any IO and services requests from an in memory byte buffer
+	/// Every request will succeed with this overload, note that it won't actually return mocked responses
+	/// so using this overload might fail if you are using it to test high level bits that need to deserialize the response.
 	/// </summary>
-	public class InMemoryConnection : ITransportClient
-	{
-		private static readonly byte[] EmptyBody = Encoding.UTF8.GetBytes("");
-		private readonly string _contentType;
-		private readonly Exception _exception;
-		private readonly byte[] _responseBody;
-		private readonly int _statusCode;
-		private readonly Dictionary<string, IEnumerable<string>> _headers;
+	public InMemoryConnection() => _statusCode = 200;
 
-		/// <summary>
-		/// Every request will succeed with this overload, note that it won't actually return mocked responses
-		/// so using this overload might fail if you are using it to test high level bits that need to deserialize the response.
-		/// </summary>
-		public InMemoryConnection() => _statusCode = 200;
-
-		/// <inheritdoc cref="InMemoryConnection"/>
-		public InMemoryConnection(byte[] responseBody, int statusCode = 200, Exception exception = null, string contentType = RequestData.MimeType, Dictionary<string, IEnumerable<string>> headers = null)
-		{
-			_responseBody = responseBody;
-			_statusCode = statusCode;
-			_exception = exception;
-			_contentType = contentType;
-			_headers = headers;
-		}
-
-		/// <inheritdoc cref="ITransportClient.Request{TResponse}"/>>
-		public virtual TResponse Request<TResponse>(RequestData requestData)
-			where TResponse : class, ITransportResponse, new() =>
-			ReturnConnectionStatus<TResponse>(requestData);
+	/// <inheritdoc cref="InMemoryConnection"/>
+	public InMemoryConnection(byte[] responseBody, int statusCode = 200, Exception exception = null, string contentType = RequestData.MimeType, Dictionary<string, IEnumerable<string>> headers = null)
+	{
+		_responseBody = responseBody;
+		_statusCode = statusCode;
+		_exception = exception;
+		_contentType = contentType;
+		_headers = headers;
+	}
 
-		/// <inheritdoc cref="ITransportClient.RequestAsync{TResponse}"/>>
-		public virtual Task<TResponse> RequestAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken)
-			where TResponse : class, ITransportResponse, new() =>
-			ReturnConnectionStatusAsync<TResponse>(requestData, cancellationToken);
+	/// <inheritdoc cref="TransportClient.Request{TResponse}"/>>
+	public override TResponse Request<TResponse>(RequestData requestData) =>
+		ReturnConnectionStatus<TResponse>(requestData);
 
-		void IDisposable.Dispose() => DisposeManagedResources();
+	/// <inheritdoc cref="TransportClient.RequestAsync{TResponse}"/>>
+	public override Task<TResponse> RequestAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken) =>
+		ReturnConnectionStatusAsync<TResponse>(requestData, cancellationToken);
 
-		/// <summary>
-		/// Allow subclasses to provide their own implementations for <see cref="ITransportClient.Request{TResponse}"/> while reusing the more complex logic
-		/// to create a response
-		/// </summary>
-		/// <param name="requestData">An instance of <see cref="RequestData"/> describing where and how to call out to</param>
-		/// <param name="responseBody">The bytes intended to be used as return</param>
-		/// <param name="statusCode">The status code that the responses <see cref="ITransportResponse.ApiCall"/> should return</param>
-		/// <param name="contentType"></param>
-		protected TResponse ReturnConnectionStatus<TResponse>(RequestData requestData, byte[] responseBody = null, int? statusCode = null,
-			string contentType = null)
-			where TResponse : class, ITransportResponse, new()
+	/// <summary>
+	/// Allow subclasses to provide their own implementations for <see cref="TransportClient.Request{TResponse}"/> while reusing the more complex logic
+	/// to create a response
+	/// </summary>
+	/// <param name="requestData">An instance of <see cref="RequestData"/> describing where and how to call out to</param>
+	/// <param name="responseBody">The bytes intended to be used as return</param>
+	/// <param name="statusCode">The status code that the responses <see cref="TransportResponse.ApiCallDetails"/> should return</param>
+	/// <param name="contentType"></param>
+	internal TResponse ReturnConnectionStatus<TResponse>(RequestData requestData, byte[] responseBody = null, int? statusCode = null,
+		string contentType = null)
+		where TResponse : TransportResponse, new()
+	{
+		var body = responseBody ?? _responseBody;
+		var data = requestData.PostData;
+		if (data != null)
 		{
-			var body = responseBody ?? _responseBody;
-			var data = requestData.PostData;
-			if (data != null)
+			using (var stream = requestData.MemoryStreamFactory.Create())
 			{
-				using (var stream = requestData.MemoryStreamFactory.Create())
+				if (requestData.HttpCompression)
 				{
-					if (requestData.HttpCompression)
-					{
-						using var zipStream = new GZipStream(stream, CompressionMode.Compress);
-						data.Write(zipStream, requestData.ConnectionSettings);
-					}
-					else
-						data.Write(stream, requestData.ConnectionSettings);
+					using var zipStream = new GZipStream(stream, CompressionMode.Compress);
+					data.Write(zipStream, requestData.ConnectionSettings);
 				}
+				else
+					data.Write(stream, requestData.ConnectionSettings);
 			}
-			requestData.MadeItToResponse = true;
-
-			var sc = statusCode ?? _statusCode;
-			Stream s = body != null ? requestData.MemoryStreamFactory.Create(body) : requestData.MemoryStreamFactory.Create(EmptyBody);
-			return requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponse<TResponse>(requestData, _exception, sc, _headers, s, contentType ?? _contentType ?? RequestData.MimeType, body?.Length ?? 0, null, null);
 		}
+		requestData.MadeItToResponse = true;
 
-		/// <inheritdoc cref="ReturnConnectionStatus{TResponse}"/>>
-		protected async Task<TResponse> ReturnConnectionStatusAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken,
-			byte[] responseBody = null, int? statusCode = null, string contentType = null)
-			where TResponse : class, ITransportResponse, new()
+		var sc = statusCode ?? _statusCode;
+		Stream s = body != null ? requestData.MemoryStreamFactory.Create(body) : requestData.MemoryStreamFactory.Create(EmptyBody);
+		return requestData.ConnectionSettings.ProductRegistration.ResponseBuilder.ToResponse<TResponse>(requestData, _exception, sc, _headers, s, contentType ?? _contentType ?? RequestData.MimeType, body?.Length ?? 0, null, null);
+	}
+
+	/// <inheritdoc cref="ReturnConnectionStatus{TResponse}"/>>
+	internal async Task<TResponse> ReturnConnectionStatusAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken,
+		byte[] responseBody = null, int? statusCode = null, string contentType = null)
+		where TResponse : TransportResponse, new()
+	{
+		var body = responseBody ?? _responseBody;
+		var data = requestData.PostData;
+		if (data != null)
 		{
-			var body = responseBody ?? _responseBody;
-			var data = requestData.PostData;
-			if (data != null)
+			using (var stream = requestData.MemoryStreamFactory.Create())
 			{
-				using (var stream = requestData.MemoryStreamFactory.Create())
+				if (requestData.HttpCompression)
 				{
-					if (requestData.HttpCompression)
-					{
-						using var zipStream = new GZipStream(stream, CompressionMode.Compress);
-						await data.WriteAsync(zipStream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
-					}
-					else
-						await data.WriteAsync(stream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
+					using var zipStream = new GZipStream(stream, CompressionMode.Compress);
+					await data.WriteAsync(zipStream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
 				}
+				else
+					await data.WriteAsync(stream, requestData.ConnectionSettings, cancellationToken).ConfigureAwait(false);
 			}
-			requestData.MadeItToResponse = true;
-
-			var sc = statusCode ?? _statusCode;
-			Stream s = body != null ? requestData.MemoryStreamFactory.Create(body) : requestData.MemoryStreamFactory.Create(EmptyBody);
-			return await requestData.ConnectionSettings.ProductRegistration.ResponseBuilder
-				.ToResponseAsync<TResponse>(requestData, _exception, sc, _headers, s, contentType ?? _contentType, body?.Length ?? 0, null, null, cancellationToken)
-				.ConfigureAwait(false);
 		}
+		requestData.MadeItToResponse = true;
 
-		/// <summary> Allows subclasses to hook into the parents dispose </summary>
-		protected virtual void DisposeManagedResources() { }
+		var sc = statusCode ?? _statusCode;
+		Stream s = body != null ? requestData.MemoryStreamFactory.Create(body) : requestData.MemoryStreamFactory.Create(EmptyBody);
+		return await requestData.ConnectionSettings.ProductRegistration.ResponseBuilder
+			.ToResponseAsync<TResponse>(requestData, _exception, sc, _headers, s, contentType ?? _contentType, body?.Length ?? 0, null, null, cancellationToken)
+			.ConfigureAwait(false);
 	}
 }
diff --git a/src/Elastic.Transport/Components/TransportClient/TransportClient.cs b/src/Elastic.Transport/Components/TransportClient/TransportClient.cs
new file mode 100644
index 0000000..0ed4ac4
--- /dev/null
+++ b/src/Elastic.Transport/Components/TransportClient/TransportClient.cs
@@ -0,0 +1,88 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Elastic.Transport;
+
+/// <summary>
+/// This interface abstracts the actual IO <see cref="HttpTransport{TConnectionSettings}"/> performs.
+/// <para><see cref="HttpTransport{TConnectionSettings}"/> holds a single instance of this class</para>
+/// <para>The instance to be used is provided to the constructor of <see cref="ITransportConfiguration"/> implementations</para>
+/// <para>Where its exposed under <see cref="ITransportConfiguration.Connection"/></para>
+/// </summary>
+public abstract class TransportClient : IDisposable
+{
+	private bool _disposed = false;
+
+	internal TransportClient() { }
+
+	/// <summary>
+	/// Perform a request to the endpoint described by <paramref name="requestData"/> using its associated configuration.
+	/// </summary>
+	/// <param name="requestData">An object describing where and how to perform the IO call</param>
+	/// <param name="cancellationToken"></param>
+	/// <typeparam name="TResponse">
+	/// An implementation of <see cref="TransportResponse"/> ensuring enough information is available
+	/// for <see cref="RequestPipeline"/> and <see cref="HttpTransport{TConnectionSettings}"/> to determine what to
+	/// do with the response
+	/// </typeparam>
+	/// <returns>
+	/// An implementation of <see cref="TransportResponse"/> ensuring enough information is available
+	/// for <see cref="RequestPipeline"/> and <see cref="HttpTransport{TConnectionSettings}"/> to determine what to
+	/// do with the response
+	/// </returns>
+	public abstract Task<TResponse> RequestAsync<TResponse>(RequestData requestData, CancellationToken cancellationToken)
+		where TResponse : TransportResponse, new();
+
+	/// <summary>
+	/// Perform a request to the endpoint described by <paramref name="requestData"/> using its associated configuration.
+	/// </summary>
+	/// <param name="requestData">An object describing where and how to perform the IO call</param>
+	/// <typeparam name="TResponse">
+	/// An implementation of <see cref="TransportResponse"/> ensuring enough information is available
+	/// for <see cref="RequestPipeline"/> and <see cref="HttpTransport{TConnectionSettings}"/> to determine what to
+	/// do with the response
+	/// </typeparam>
+	/// <returns>
+	/// An implementation of <see cref="TransportResponse"/> ensuring enough information is available
+	/// for <see cref="RequestPipeline"/> and <see cref="HttpTransport{TConnectionSettings}"/> to determine what to
+	/// do with the response
+	/// </returns>
+	public abstract TResponse Request<TResponse>(RequestData requestData)
+		where TResponse : TransportResponse, new();
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public void Dispose()
+	{
+		Dispose(disposing: true);
+		GC.SuppressFinalize(this);
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="disposing"></param>
+	protected virtual void Dispose(bool disposing)
+	{
+		if (_disposed)
+			return;
+
+		if (disposing)
+		{
+			DisposeManagedResources();
+		}
+
+		_disposed = true;
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	protected virtual void DisposeManagedResources() { }
+}
diff --git a/src/Elastic.Transport/Components/TransportClient/WebProxy.cs b/src/Elastic.Transport/Components/TransportClient/WebProxy.cs
new file mode 100644
index 0000000..3f3ca20
--- /dev/null
+++ b/src/Elastic.Transport/Components/TransportClient/WebProxy.cs
@@ -0,0 +1,23 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+#if DOTNETCORE
+using System;
+using System.Net;
+
+namespace Elastic.Transport;
+
+internal class WebProxy : IWebProxy
+{
+	private readonly Uri _uri;
+
+	public WebProxy(Uri uri) => _uri = uri;
+
+	public ICredentials Credentials { get; set; }
+
+	public Uri GetProxy(Uri destination) => _uri;
+
+	public bool IsBypassed(Uri host) => host.IsLoopback;
+}
+#endif
diff --git a/src/Elastic.Transport/Configuration/ConnectionInfo.cs b/src/Elastic.Transport/Configuration/ConnectionInfo.cs
index c80cd20..1405686 100644
--- a/src/Elastic.Transport/Configuration/ConnectionInfo.cs
+++ b/src/Elastic.Transport/Configuration/ConnectionInfo.cs
@@ -7,45 +7,44 @@
 using System.Net.Http;
 #endif
 
-namespace Elastic.Transport
-{
-	internal static class ConnectionInfo
-	{ 
-		public static bool UsingCurlHandler
+namespace Elastic.Transport;
+
+internal static class ConnectionInfo
+{ 
+	public static bool UsingCurlHandler
+	{
+		get
 		{
-			get
-			{
-				// Not available after .NET 5.0
+			// Not available after .NET 5.0
 #if NET5_0_OR_GREATER || !DOTNETCORE
 #pragma warning disable IDE0025 // Use expression body for properties
-				return false;
+			return false;
 #pragma warning restore IDE0025 // Use expression body for properties
 #else
-				var curlHandlerExists = typeof(HttpClientHandler).Assembly.GetType("System.Net.Http.CurlHandler") != null;
-				if (!curlHandlerExists)
-					return false;
+			var curlHandlerExists = typeof(HttpClientHandler).Assembly.GetType("System.Net.Http.CurlHandler") != null;
+			if (!curlHandlerExists)
+				return false;
 
-				var socketsHandlerExists = typeof(HttpClientHandler).Assembly.GetType("System.Net.Http.SocketsHttpHandler") != null;
-				// running on a .NET core version with CurlHandler, before the existence of SocketsHttpHandler.
-				// Must be using CurlHandler.
-				if (!socketsHandlerExists)
-					return true;
+			var socketsHandlerExists = typeof(HttpClientHandler).Assembly.GetType("System.Net.Http.SocketsHttpHandler") != null;
+			// running on a .NET core version with CurlHandler, before the existence of SocketsHttpHandler.
+			// Must be using CurlHandler.
+			if (!socketsHandlerExists)
+				return true;
 
-				if (AppContext.TryGetSwitch("System.Net.Http.UseSocketsHttpHandler", out var isEnabled))
-					return !isEnabled;
+			if (AppContext.TryGetSwitch("System.Net.Http.UseSocketsHttpHandler", out var isEnabled))
+				return !isEnabled;
 
-				var environmentVariable =
-					Environment.GetEnvironmentVariable("DOTNET_SYSTEM_NET_HTTP_USESOCKETSHTTPHANDLER");
+			var environmentVariable =
+				Environment.GetEnvironmentVariable("DOTNET_SYSTEM_NET_HTTP_USESOCKETSHTTPHANDLER");
 
-				// SocketsHandler exists and no environment variable exists to disable it.
-				// Must be using SocketsHandler and not CurlHandler
-				if (environmentVariable == null)
-					return false;
+			// SocketsHandler exists and no environment variable exists to disable it.
+			// Must be using SocketsHandler and not CurlHandler
+			if (environmentVariable == null)
+				return false;
 
-				return environmentVariable.Equals("false", StringComparison.OrdinalIgnoreCase) ||
-					environmentVariable.Equals("0");
+			return environmentVariable.Equals("false", StringComparison.OrdinalIgnoreCase) ||
+				environmentVariable.Equals("0");
 #endif
-			}
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Configuration/HeadersList.cs b/src/Elastic.Transport/Configuration/HeadersList.cs
index 0d82eca..3f56bb3 100644
--- a/src/Elastic.Transport/Configuration/HeadersList.cs
+++ b/src/Elastic.Transport/Configuration/HeadersList.cs
@@ -7,111 +7,110 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Represents a unique, case-insensitive, immutable collection of header names.
+/// </summary>
+public readonly struct HeadersList : IEnumerable<string>
 {
+	private readonly List<string> _headers;
+
 	/// <summary>
-	/// Represents a unique, case-insensitive, immutable collection of header names.
+	/// Create a new <see cref="HeadersList"/> from an existing enumerable of header names.
+	/// Duplicate names, including those which only differ by case, will be ignored.
 	/// </summary>
-	public struct HeadersList : IEnumerable<string>
+	/// <param name="headers">The header names to initialise the <see cref="HeadersList"/> with.</param>
+	public HeadersList(IEnumerable<string> headers)
 	{
-		private readonly List<string> _headers;
-
-		/// <summary>
-		/// Create a new <see cref="HeadersList"/> from an existing enumerable of header names.
-		/// Duplicate names, including those which only differ by case, will be ignored.
-		/// </summary>
-		/// <param name="headers">The header names to initialise the <see cref="HeadersList"/> with.</param>
-		public HeadersList(IEnumerable<string> headers)
-		{
-			_headers = new List<string>();
+		_headers = new List<string>();
 
-			foreach (var header in headers)
+		foreach (var header in headers)
+		{
+			if (!_headers.Contains(header, StringComparer.OrdinalIgnoreCase))
 			{
-				if (!_headers.Contains(header, StringComparer.OrdinalIgnoreCase))
-				{
-					_headers.Add(header);
-				}
+				_headers.Add(header);
 			}
 		}
+	}
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="headers"></param>
-		/// <param name="additionalHeader"></param>
-		public HeadersList(IEnumerable<string> headers, string additionalHeader)
-		{
-			_headers = new List<string>();
-
-			foreach (var header in headers)
-			{
-				if (!_headers.Contains(header, StringComparer.OrdinalIgnoreCase))
-				{
-					_headers.Add(header);
-				}
-			}
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="headers"></param>
+	/// <param name="additionalHeader"></param>
+	public HeadersList(IEnumerable<string> headers, string additionalHeader)
+	{
+		_headers = new List<string>();
 
-			if (!_headers.Contains(additionalHeader, StringComparer.OrdinalIgnoreCase))
+		foreach (var header in headers)
+		{
+			if (!_headers.Contains(header, StringComparer.OrdinalIgnoreCase))
 			{
-				_headers.Add(additionalHeader);
+				_headers.Add(header);
 			}
 		}
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="headers"></param>
-		/// <param name="otherHeaders"></param>
-		public HeadersList(IEnumerable<string> headers, IEnumerable<string> otherHeaders)
+		if (!_headers.Contains(additionalHeader, StringComparer.OrdinalIgnoreCase))
 		{
-			_headers = new List<string>();
+			_headers.Add(additionalHeader);
+		}
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="headers"></param>
+	/// <param name="otherHeaders"></param>
+	public HeadersList(IEnumerable<string> headers, IEnumerable<string> otherHeaders)
+	{
+		_headers = new List<string>();
 
-			foreach (var header in headers)
+		foreach (var header in headers)
+		{
+			if (!_headers.Contains(header, StringComparer.OrdinalIgnoreCase))
 			{
-				if (!_headers.Contains(header, StringComparer.OrdinalIgnoreCase))
-				{
-					_headers.Add(header);
-				}
+				_headers.Add(header);
 			}
+		}
 
-			foreach (var header in otherHeaders)
+		foreach (var header in otherHeaders)
+		{
+			if (!_headers.Contains(header, StringComparer.OrdinalIgnoreCase))
 			{
-				if (!_headers.Contains(header, StringComparer.OrdinalIgnoreCase))
-				{
-					_headers.Add(header);
-				}
+				_headers.Add(header);
 			}
 		}
+	}
 
-		/// <summary>
-		/// Create a new <see cref="HeadersList"/> initialised with a single header name.
-		/// </summary>
-		/// <param name="header">The header name to initialise the <see cref="HeadersList"/> with.</param>
-		public HeadersList(string header) => _headers = new List<string> { header };
+	/// <summary>
+	/// Create a new <see cref="HeadersList"/> initialised with a single header name.
+	/// </summary>
+	/// <param name="header">The header name to initialise the <see cref="HeadersList"/> with.</param>
+	public HeadersList(string header) => _headers = new List<string> { header };
+
+	/// <summary>
+	/// Gets the number of elements contained in the <see cref="HeadersList"/>.
+	/// </summary>
+	public int Count => _headers is null ? 0 : _headers.Count;
 
-		/// <summary>
-		/// Gets the number of elements contained in the <see cref="HeadersList"/>.
-		/// </summary>
-		public int Count => _headers is null ? 0 : _headers.Count;
+	/// <inheritdoc />
+	public IEnumerator<string> GetEnumerator() => _headers?.GetEnumerator() ?? (IEnumerator<string>)new EmptyEnumerator<string>();
 
-		/// <inheritdoc />
-		public IEnumerator<string> GetEnumerator() => _headers?.GetEnumerator() ?? (IEnumerator<string>)new EmptyEnumerator<string>();
+	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-		IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+	internal struct EmptyEnumerator<T> : IEnumerator<T>
+	{
+		public T Current => default;
+		object IEnumerator.Current => Current;
+		public bool MoveNext() => false;
 
-		internal struct EmptyEnumerator<T> : IEnumerator<T>
+		public void Reset()
 		{
-			public T Current => default;
-			object IEnumerator.Current => Current;
-			public bool MoveNext() => false;
-
-			public void Reset()
-			{
-			}
+		}
 
-			public void Dispose()
-			{
-			}
+		public void Dispose()
+		{
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Configuration/ITransportConfiguration.cs b/src/Elastic.Transport/Configuration/ITransportConfiguration.cs
index 68607a5..6ba5926 100644
--- a/src/Elastic.Transport/Configuration/ITransportConfiguration.cs
+++ b/src/Elastic.Transport/Configuration/ITransportConfiguration.cs
@@ -11,289 +11,288 @@
 using System.Threading;
 using Elastic.Transport.Products;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// All the transport configuration that you as the user can use to steer the behavior of the <see cref="HttpTransport{TConnectionSettings}"/> and all the components such
+/// as <see cref="TransportClient"/> <see cref="NodePool"/> and <see cref="Serializer"/>.
+/// </summary>
+public interface ITransportConfiguration : IDisposable
 {
+	/// <inheritdoc cref="AuthorizationHeader"/>
+	AuthorizationHeader Authentication { get; }
+
+	/// <summary> Provides a semaphoreslim to transport implementations that need to limit access to a resource</summary>
+	SemaphoreSlim BootstrapLock { get; }
+
+	/// <summary>
+	/// Use the following certificates to authenticate all HTTP requests. You can also set them on individual
+	/// request using <see cref="RequestConfiguration.ClientCertificates" />
+	/// </summary>
+	X509CertificateCollection ClientCertificates { get; }
+
+	/// <summary> The connection abstraction behind which all actual IO happens</summary>
+	TransportClient Connection { get; }
+
+	/// <summary>
+	/// Limits the number of concurrent connections that can be opened to an endpoint. Defaults to 80 (see
+	/// <see cref="TransportConfiguration.DefaultConnectionLimit" />).
+	/// <para>
+	/// For Desktop CLR, this setting applies to the DefaultConnectionLimit property on the  ServicePointManager object when creating
+	/// ServicePoint objects, affecting the default <see cref="TransportClient" /> implementation.
+	/// </para>
+	/// <para>
+	/// For Core CLR, this setting applies to the MaxConnectionsPerServer property on the HttpClientHandler instances used by the HttpClient
+	/// inside the default <see cref="TransportClient" /> implementation
+	/// </para>
+	/// </summary>
+	int ConnectionLimit { get; }
+
+	/// <summary> The connection pool to use when talking with Elasticsearch </summary>
+	NodePool NodePool { get; }
+
+	/// <summary>
+	/// Returns information about the current product making use of the transport.
+	/// </summary>
+	ProductRegistration ProductRegistration { get; }
+
+	/// <summary>
+	/// The time to put dead nodes out of rotation (this will be multiplied by the number of times they've been dead)
+	/// </summary>
+	TimeSpan? DeadTimeout { get; }
+
+	/// <summary>
+	/// Disabled proxy detection on the webrequest, in some cases this may speed up the first connection
+	/// your appdomain makes, in other cases it will actually increase the time for the first connection.
+	/// No silver bullet! use with care!
+	/// </summary>
+	bool DisableAutomaticProxyDetection { get; }
+
+	/// <summary>
+	/// When set to true will disable (de)serializing directly to the request and response stream and return a byte[]
+	/// copy of the raw request and response. Defaults to false
+	/// </summary>
+	bool DisableDirectStreaming { get; }
+
+	/// <summary>
+	/// This signals that we do not want to send initial pings to unknown/previously dead nodes
+	/// and just send the call straightaway
+	/// </summary>
+	bool DisablePings { get; }
+
+	/// <summary>
+	/// Enable gzip compressed requests and responses
+	/// </summary>
+	bool EnableHttpCompression { get; }
+
+	/// <summary>
+	/// Try to send these headers for every request
+	/// </summary>
+	NameValueCollection Headers { get; }
+
+	/// <summary>
+	/// Whether HTTP pipelining is enabled. The default is <c>true</c>
+	/// </summary>
+	bool HttpPipeliningEnabled { get; }
+
+	/// <summary>
+	/// KeepAliveInterval - specifies the interval, in milliseconds, between
+	/// when successive keep-alive packets are sent if no acknowledgement is
+	/// received.
+	/// </summary>
+	TimeSpan? KeepAliveInterval { get; }
+
+	/// <summary>
+	/// KeepAliveTime - specifies the timeout, in milliseconds, with no
+	/// activity until the first keep-alive packet is sent.
+	/// </summary>
+	TimeSpan? KeepAliveTime { get; }
+
+	/// <summary>
+	/// The maximum amount of time a node is allowed to marked dead
+	/// </summary>
+	TimeSpan? MaxDeadTimeout { get; }
+
+	/// <summary>
+	/// When a retryable exception occurs or status code is returned this controls the maximum
+	/// amount of times we should retry the call to Elasticsearch
+	/// </summary>
+	int? MaxRetries { get; }
+
+	/// <summary>
+	/// Limits the total runtime including retries separately from <see cref="RequestTimeout" />
+	/// <pre>
+	/// When not specified defaults to <see cref="RequestTimeout" /> which itself defaults to 60 seconds
+	/// </pre>
+	/// </summary>
+	TimeSpan? MaxRetryTimeout { get; }
+
+	/// <summary> Provides a memory stream factory</summary>
+	MemoryStreamFactory MemoryStreamFactory { get; }
+
+	/// <summary>
+	/// Register a predicate to select which nodes that you want to execute API calls on. Note that sniffing requests omit this predicate and
+	/// always execute on all nodes.
+	/// When using an <see cref="NodePool" /> implementation that supports reseeding of nodes, this will default to omitting master only
+	/// node from regular API calls.
+	/// When using static or single node connection pooling it is assumed the list of node you instantiate the client with should be taken
+	/// verbatim.
+	/// </summary>
+	Func<Node, bool> NodePredicate { get; }
+
+	/// <summary>
+	/// Allows you to register a callback every time a an API call is returned
+	/// </summary>
+	Action<ApiCallDetails> OnRequestCompleted { get; }
+
+	/// <summary>
+	/// An action to run when the <see cref="RequestData" /> for a request has been
+	/// created.
+	/// </summary>
+	Action<RequestData> OnRequestDataCreated { get; }
+
+	/// <summary>
+	/// When enabled, all headers from the HTTP response will be included in the <see cref="ApiCallDetails"/>.
+	/// </summary>
+	bool? ParseAllHeaders { get; }
+
+	/// <summary>
+	/// The timeout in milliseconds to use for ping requests, which are issued to determine whether a node is alive
+	/// </summary>
+	TimeSpan? PingTimeout { get; }
+
+	/// <summary>
+	/// When set will force all connections through this proxy
+	/// </summary>
+	string ProxyAddress { get; }
+
+	/// <summary>
+	/// The password for the proxy, when configured
+	/// </summary>
+	string ProxyPassword { get; }
+
+	/// <summary>
+	/// The username for the proxy, when configured
+	/// </summary>
+	string ProxyUsername { get; }
+
+	/// <summary>
+	/// Append these query string parameters automatically to every request
+	/// </summary>
+	NameValueCollection QueryStringParameters { get; }
+
+	/// <summary>The serializer to use to serialize requests and deserialize responses</summary>
+	Serializer RequestResponseSerializer { get; }
+
+	/// <summary>
+	/// The timeout in milliseconds for each request to Elasticsearch
+	/// </summary>
+	TimeSpan RequestTimeout { get; }
+
+	/// <summary>
+	/// A <see cref="HeadersList"/> containing the names of all HTTP response headers to attempt to parse and
+	/// included on the <see cref="ApiCallDetails"/>.
+	/// </summary>
+	HeadersList ResponseHeadersToParse { get; }
+
 	/// <summary>
-	/// All the transport configuration that you as the user can use to steer the behavior of the <see cref="ITransport{TConnectionSettings}"/> and all the components such
-	/// as <see cref="ITransportClient"/> <see cref="NodePool"/> and <see cref="Serializer"/>.
-	/// </summary>
-	public interface ITransportConfiguration : IDisposable
-	{
-		/// <inheritdoc cref="AuthorizationHeader"/>
-		AuthorizationHeader Authentication { get; }
-
-		/// <summary> Provides a semaphoreslim to transport implementations that need to limit access to a resource</summary>
-		SemaphoreSlim BootstrapLock { get; }
-
-		/// <summary>
-		/// Use the following certificates to authenticate all HTTP requests. You can also set them on individual
-		/// request using <see cref="RequestConfiguration.ClientCertificates" />
-		/// </summary>
-		X509CertificateCollection ClientCertificates { get; }
-
-		/// <summary> The connection abstraction behind which all actual IO happens</summary>
-		ITransportClient Connection { get; }
-
-		/// <summary>
-		/// Limits the number of concurrent connections that can be opened to an endpoint. Defaults to 80 (see
-		/// <see cref="TransportConfiguration.DefaultConnectionLimit" />).
-		/// <para>
-		/// For Desktop CLR, this setting applies to the DefaultConnectionLimit property on the  ServicePointManager object when creating
-		/// ServicePoint objects, affecting the default <see cref="ITransportClient" /> implementation.
-		/// </para>
-		/// <para>
-		/// For Core CLR, this setting applies to the MaxConnectionsPerServer property on the HttpClientHandler instances used by the HttpClient
-		/// inside the default <see cref="ITransportClient" /> implementation
-		/// </para>
-		/// </summary>
-		int ConnectionLimit { get; }
-
-		/// <summary> The connection pool to use when talking with Elasticsearch </summary>
-		NodePool NodePool { get; }
-
-		/// <summary>
-		/// Returns information about the current product making use of the transport.
-		/// </summary>
-		IProductRegistration ProductRegistration { get; }
-
-		/// <summary>
-		/// The time to put dead nodes out of rotation (this will be multiplied by the number of times they've been dead)
-		/// </summary>
-		TimeSpan? DeadTimeout { get; }
-
-		/// <summary>
-		/// Disabled proxy detection on the webrequest, in some cases this may speed up the first connection
-		/// your appdomain makes, in other cases it will actually increase the time for the first connection.
-		/// No silver bullet! use with care!
-		/// </summary>
-		bool DisableAutomaticProxyDetection { get; }
-
-		/// <summary>
-		/// When set to true will disable (de)serializing directly to the request and response stream and return a byte[]
-		/// copy of the raw request and response. Defaults to false
-		/// </summary>
-		bool DisableDirectStreaming { get; }
-
-		/// <summary>
-		/// This signals that we do not want to send initial pings to unknown/previously dead nodes
-		/// and just send the call straightaway
-		/// </summary>
-		bool DisablePings { get; }
-
-		/// <summary>
-		/// Enable gzip compressed requests and responses
-		/// </summary>
-		bool EnableHttpCompression { get; }
-
-		/// <summary>
-		/// Try to send these headers for every request
-		/// </summary>
-		NameValueCollection Headers { get; }
-
-		/// <summary>
-		/// Whether HTTP pipelining is enabled. The default is <c>true</c>
-		/// </summary>
-		bool HttpPipeliningEnabled { get; }
-
-		/// <summary>
-		/// KeepAliveInterval - specifies the interval, in milliseconds, between
-		/// when successive keep-alive packets are sent if no acknowledgement is
-		/// received.
-		/// </summary>
-		TimeSpan? KeepAliveInterval { get; }
-
-		/// <summary>
-		/// KeepAliveTime - specifies the timeout, in milliseconds, with no
-		/// activity until the first keep-alive packet is sent.
-		/// </summary>
-		TimeSpan? KeepAliveTime { get; }
-
-		/// <summary>
-		/// The maximum amount of time a node is allowed to marked dead
-		/// </summary>
-		TimeSpan? MaxDeadTimeout { get; }
-
-		/// <summary>
-		/// When a retryable exception occurs or status code is returned this controls the maximum
-		/// amount of times we should retry the call to Elasticsearch
-		/// </summary>
-		int? MaxRetries { get; }
-
-		/// <summary>
-		/// Limits the total runtime including retries separately from <see cref="RequestTimeout" />
-		/// <pre>
-		/// When not specified defaults to <see cref="RequestTimeout" /> which itself defaults to 60 seconds
-		/// </pre>
-		/// </summary>
-		TimeSpan? MaxRetryTimeout { get; }
-
-		/// <summary> Provides a memory stream factory</summary>
-		IMemoryStreamFactory MemoryStreamFactory { get; }
-
-		/// <summary>
-		/// Register a predicate to select which nodes that you want to execute API calls on. Note that sniffing requests omit this predicate and
-		/// always execute on all nodes.
-		/// When using an <see cref="NodePool" /> implementation that supports reseeding of nodes, this will default to omitting master only
-		/// node from regular API calls.
-		/// When using static or single node connection pooling it is assumed the list of node you instantiate the client with should be taken
-		/// verbatim.
-		/// </summary>
-		Func<Node, bool> NodePredicate { get; }
-
-		/// <summary>
-		/// Allows you to register a callback every time a an API call is returned
-		/// </summary>
-		Action<IApiCallDetails> OnRequestCompleted { get; }
-
-		/// <summary>
-		/// An action to run when the <see cref="RequestData" /> for a request has been
-		/// created.
-		/// </summary>
-		Action<RequestData> OnRequestDataCreated { get; }
-
-		/// <summary>
-		/// When enabled, all headers from the HTTP response will be included in the <see cref="IApiCallDetails"/>.
-		/// </summary>
-		bool? ParseAllHeaders { get; }
-
-		/// <summary>
-		/// The timeout in milliseconds to use for ping requests, which are issued to determine whether a node is alive
-		/// </summary>
-		TimeSpan? PingTimeout { get; }
-
-		/// <summary>
-		/// When set will force all connections through this proxy
-		/// </summary>
-		string ProxyAddress { get; }
-
-		/// <summary>
-		/// The password for the proxy, when configured
-		/// </summary>
-		string ProxyPassword { get; }
-
-		/// <summary>
-		/// The username for the proxy, when configured
-		/// </summary>
-		string ProxyUsername { get; }
-
-		/// <summary>
-		/// Append these query string parameters automatically to every request
-		/// </summary>
-		NameValueCollection QueryStringParameters { get; }
-
-		/// <summary>The serializer to use to serialize requests and deserialize responses</summary>
-		Serializer RequestResponseSerializer { get; }
-
-		/// <summary>
-		/// The timeout in milliseconds for each request to Elasticsearch
-		/// </summary>
-		TimeSpan RequestTimeout { get; }
-
-		/// <summary>
-		/// A <see cref="HeadersList"/> containing the names of all HTTP response headers to attempt to parse and
-		/// included on the <see cref="IApiCallDetails"/>.
-		/// </summary>
-		HeadersList ResponseHeadersToParse { get; }
-
-		/// <summary>
-		/// Register a ServerCertificateValidationCallback per request
-		/// </summary>
-		Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> ServerCertificateValidationCallback { get; }
-
-		/// <summary>
-		/// During development, the server certificate fingerprint may be provided. When present, it is used to validate the
-		/// certificate sent by the server. The fingerprint is expected to be the hex string representing the SHA256 public key fingerprint.
-		/// </summary>
-		string CertificateFingerprint { get; }
-
-		/// <summary>
-		/// Configure the client to skip deserialization of certain status codes e.g: you run Elasticsearch behind a proxy that returns an unexpected
-		/// json format
-		/// </summary>
-		IReadOnlyCollection<int> SkipDeserializationForStatusCodes { get; }
-
-		/// <summary>
-		/// Force a new sniff for the cluster when the cluster state information is older than
-		/// the specified timespan
-		/// </summary>
-		TimeSpan? SniffInformationLifeSpan { get; }
-
-		/// <summary>
-		/// Force a new sniff for the cluster state every time a connection dies
-		/// </summary>
-		bool SniffsOnConnectionFault { get; }
-
-		/// <summary>
-		/// Sniff the cluster state immediately on startup
-		/// </summary>
-		bool SniffsOnStartup { get; }
-
-		/// <summary>
-		/// Instead of following a c/go like error checking on response.IsValid do throw an exception (except when <see cref="IApiCallDetails.SuccessOrKnownError"/> is false)
-		/// on the client when a call resulted in an exception on either the client or the Elasticsearch server.
-		/// <para>Reasons for such exceptions could be search parser errors, index missing exceptions, etc...</para>
-		/// </summary>
-		bool ThrowExceptions { get; }
-
-		/// <summary>
-		/// Access to <see cref="UrlFormatter"/> instance that is aware of this <see cref="ITransportConfiguration"/> instance
-		/// </summary>
-		UrlFormatter UrlFormatter { get; }
-
-		/// <summary>
-		/// The user agent string to send with requests. Useful for debugging purposes to understand client and framework
-		/// versions that initiate requests to Elasticsearch
-		/// </summary>
-		UserAgent UserAgent { get; }
-
-		/// <summary>
-		/// Allow you to override the status code inspection that sets <see cref="IApiCallDetails.Success"/>
-		/// <para>
-		/// Defaults to validating the statusCode is greater or equal to 200 and less then 300
-		/// </para>
-		/// <para>
-		/// When the request is using <see cref="HttpMethod.HEAD"/> 404 is valid out of the box as well
-		/// </para>
-		/// <para></para>
-		/// <para>NOTE: if a request specifies <see cref="IRequestConfiguration.AllowedStatusCodes"/> this takes precedence</para>
-		/// </summary>
-		Func<HttpMethod, int, bool> StatusCodeToResponseSuccess { get; }
-
-		/// <summary>
-		/// Whether the request should be sent with chunked Transfer-Encoding.
-		/// </summary>
-		bool TransferEncodingChunked { get; }
-
-		/// <summary>
-		/// DnsRefreshTimeout for the connections. Defaults to 5 minutes.
-		/// </summary>
-		TimeSpan DnsRefreshTimeout { get; }
-
-		/// <summary>
-		/// Enable statistics about TCP connections to be collected when making a request
-		/// </summary>
-		bool EnableTcpStats { get; }
-
-		/// <summary>
-		/// Enable statistics about thread pools to be collected when making a request
-		/// </summary>
-		bool EnableThreadPoolStats { get; }
-
-		/// <summary>
-		/// Provide hints to serializer and products to produce pretty, non minified json.
-		/// <para>Note: this is not a guarantee you will always get prettified json</para>
-		/// </summary>
-		bool PrettyJson { get; }
-
-		/// <summary>
-		/// Produces the client meta header for a request.
-		/// </summary>
-		MetaHeaderProvider MetaHeaderProvider { get; }
-
-		/// <summary>
-		/// Disables the meta header which is included on all requests by default. This header contains lightweight information 
-		/// about the client and runtime.
-		/// </summary>
-		bool DisableMetaHeader { get; }
-	}
+	/// Register a ServerCertificateValidationCallback per request
+	/// </summary>
+	Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> ServerCertificateValidationCallback { get; }
+
+	/// <summary>
+	/// During development, the server certificate fingerprint may be provided. When present, it is used to validate the
+	/// certificate sent by the server. The fingerprint is expected to be the hex string representing the SHA256 public key fingerprint.
+	/// </summary>
+	string CertificateFingerprint { get; }
+
+	/// <summary>
+	/// Configure the client to skip deserialization of certain status codes e.g: you run Elasticsearch behind a proxy that returns an unexpected
+	/// json format
+	/// </summary>
+	IReadOnlyCollection<int> SkipDeserializationForStatusCodes { get; }
+
+	/// <summary>
+	/// Force a new sniff for the cluster when the cluster state information is older than
+	/// the specified timespan
+	/// </summary>
+	TimeSpan? SniffInformationLifeSpan { get; }
+
+	/// <summary>
+	/// Force a new sniff for the cluster state every time a connection dies
+	/// </summary>
+	bool SniffsOnConnectionFault { get; }
+
+	/// <summary>
+	/// Sniff the cluster state immediately on startup
+	/// </summary>
+	bool SniffsOnStartup { get; }
+
+	/// <summary>
+	/// Instead of following a c/go like error checking on response.IsValid do throw an exception (except when <see cref="ApiCallDetails.SuccessOrKnownError"/> is false)
+	/// on the client when a call resulted in an exception on either the client or the Elasticsearch server.
+	/// <para>Reasons for such exceptions could be search parser errors, index missing exceptions, etc...</para>
+	/// </summary>
+	bool ThrowExceptions { get; }
+
+	/// <summary>
+	/// Access to <see cref="UrlFormatter"/> instance that is aware of this <see cref="ITransportConfiguration"/> instance
+	/// </summary>
+	UrlFormatter UrlFormatter { get; }
+
+	/// <summary>
+	/// The user agent string to send with requests. Useful for debugging purposes to understand client and framework
+	/// versions that initiate requests to Elasticsearch
+	/// </summary>
+	UserAgent UserAgent { get; }
+
+	/// <summary>
+	/// Allow you to override the status code inspection that sets <see cref="ApiCallDetails.Success"/>
+	/// <para>
+	/// Defaults to validating the statusCode is greater or equal to 200 and less then 300
+	/// </para>
+	/// <para>
+	/// When the request is using <see cref="HttpMethod.HEAD"/> 404 is valid out of the box as well
+	/// </para>
+	/// <para></para>
+	/// <para>NOTE: if a request specifies <see cref="IRequestConfiguration.AllowedStatusCodes"/> this takes precedence</para>
+	/// </summary>
+	Func<HttpMethod, int, bool> StatusCodeToResponseSuccess { get; }
+
+	/// <summary>
+	/// Whether the request should be sent with chunked Transfer-Encoding.
+	/// </summary>
+	bool TransferEncodingChunked { get; }
+
+	/// <summary>
+	/// DnsRefreshTimeout for the connections. Defaults to 5 minutes.
+	/// </summary>
+	TimeSpan DnsRefreshTimeout { get; }
+
+	/// <summary>
+	/// Enable statistics about TCP connections to be collected when making a request
+	/// </summary>
+	bool EnableTcpStats { get; }
+
+	/// <summary>
+	/// Enable statistics about thread pools to be collected when making a request
+	/// </summary>
+	bool EnableThreadPoolStats { get; }
+
+	/// <summary>
+	/// Provide hints to serializer and products to produce pretty, non minified json.
+	/// <para>Note: this is not a guarantee you will always get prettified json</para>
+	/// </summary>
+	bool PrettyJson { get; }
+
+	/// <summary>
+	/// Produces the client meta header for a request.
+	/// </summary>
+	MetaHeaderProvider MetaHeaderProvider { get; }
+
+	/// <summary>
+	/// Disables the meta header which is included on all requests by default. This header contains lightweight information 
+	/// about the client and runtime.
+	/// </summary>
+	bool DisableMetaHeader { get; }
 }
diff --git a/src/Elastic.Transport/Configuration/RequestConfiguration.cs b/src/Elastic.Transport/Configuration/RequestConfiguration.cs
index 8725f51..7f22c61 100644
--- a/src/Elastic.Transport/Configuration/RequestConfiguration.cs
+++ b/src/Elastic.Transport/Configuration/RequestConfiguration.cs
@@ -8,411 +8,410 @@
 using System.Security.Cryptography.X509Certificates;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Allows you to inject per <see cref="HttpTransport.Request{TResponse}"/> overrides to the current <see cref="ITransportConfiguration"/>.
+/// </summary>
+public interface IRequestConfiguration
 {
 	/// <summary>
-	/// Allows you to inject per <see cref="ITransport.Request{TResponse}"/> overrides to the current <see cref="ITransportConfiguration"/>.
+	/// Force a different Accept header on the request
+	/// </summary>
+	string Accept { get; set; }
+
+	/// <summary>
+	/// Treat the following statuses (on top of the 200 range) NOT as error.
+	/// </summary>
+	IReadOnlyCollection<int> AllowedStatusCodes { get; set; }
+
+	/// <summary>
+	/// Provide an authentication header override for this request
+	/// </summary>
+	AuthorizationHeader AuthenticationHeader { get; set; }
+
+	/// <summary>
+	/// Use the following client certificates to authenticate this single request
+	/// </summary>
+	X509CertificateCollection ClientCertificates { get; set; }
+
+	/// <summary>
+	/// Force a different Content-Type header on the request
+	/// </summary>
+	string ContentType { get; set; }
+
+	/// <summary>
+	/// Whether to buffer the request and response bytes for the call
+	/// </summary>
+	bool? DisableDirectStreaming { get; set; }
+
+	/// <summary>
+	/// Under no circumstance do a ping before the actual call. If a node was previously dead a small ping with
+	/// low connect timeout will be tried first in normal circumstances
+	/// </summary>
+	bool? DisablePing { get; set; }
+
+	/// <summary>
+	/// Forces no sniffing to occur on the request no matter what configuration is in place
+	/// globally
+	/// </summary>
+	bool? DisableSniff { get; set; }
+
+	/// <summary>
+	/// Whether or not this request should be pipelined. http://en.wikipedia.org/wiki/HTTP_pipelining defaults to true
+	/// </summary>
+	bool? EnableHttpPipelining { get; set; }
+
+	/// <summary>
+	/// This will force the operation on the specified node, this will bypass any configured connection pool and will no retry.
+	/// </summary>
+	Uri ForceNode { get; set; }
+
+	/// <summary>
+	/// This will override whatever is set on the connection configuration or whatever default the connectionpool has.
+	/// </summary>
+	int? MaxRetries { get; set; }
+
+	/// <summary>
+	/// Associate an Id with this user-initiated task, such that it can be located in the cluster task list.
+	/// Valid only for Elasticsearch 6.2.0+
 	/// </summary>
-	public interface IRequestConfiguration
+	string OpaqueId { get; set; }
+
+	/// <inheritdoc cref="ITransportConfiguration.ParseAllHeaders"/>
+	bool? ParseAllHeaders { get; set; }
+
+	/// <summary>
+	/// The ping timeout for this specific request
+	/// </summary>
+	TimeSpan? PingTimeout { get; set; }
+
+	/// <summary>
+	/// The timeout for this specific request, takes precedence over the global timeout settings
+	/// </summary>
+	TimeSpan? RequestTimeout { get; set; }
+
+	/// <inheritdoc cref="ITransportConfiguration.ResponseHeadersToParse"/>
+	HeadersList ResponseHeadersToParse { get; set; }
+
+	/// <summary>
+	/// Submit the request on behalf in the context of a different shield user
+	/// <pre />https://www.elastic.co/guide/en/shield/current/submitting-requests-for-other-users.html
+	/// </summary>
+	string RunAs { get; set; }
+
+	/// <summary>
+	/// Instead of following a c/go like error checking on response.IsValid do throw an exception (except when <see cref="ApiCallDetails.SuccessOrKnownError"/> is false)
+	/// on the client when a call resulted in an exception on either the client or the Elasticsearch server.
+	/// <para>Reasons for such exceptions could be search parser errors, index missing exceptions, etc...</para>
+	/// </summary>
+	bool? ThrowExceptions { get; set; }
+
+	/// <summary>
+	/// Whether the request should be sent with chunked Transfer-Encoding.
+	/// </summary>
+	bool? TransferEncodingChunked { get; set; }
+
+	/// <summary>
+	/// Try to send these headers for this single request
+	/// </summary>
+	NameValueCollection Headers { get; set; }
+
+	/// <inheritdoc cref="ITransportConfiguration.EnableTcpStats"/>
+	bool? EnableTcpStats { get; set; }
+
+	/// <inheritdoc cref="ITransportConfiguration.EnableThreadPoolStats"/>
+	bool? EnableThreadPoolStats { get; set; }
+
+	/// <summary>
+	/// Holds additional meta data about the request.
+	/// </summary>
+	RequestMetaData RequestMetaData { get; set; }
+}
+
+/// <inheritdoc cref="IRequestConfiguration"/>
+public class RequestConfiguration : IRequestConfiguration
+{
+	/// <inheritdoc />
+	public string Accept { get; set; }
+	/// <inheritdoc />
+	public IReadOnlyCollection<int> AllowedStatusCodes { get; set; }
+	/// <inheritdoc />
+	public AuthorizationHeader AuthenticationHeader { get; set; }
+	/// <inheritdoc />
+	public X509CertificateCollection ClientCertificates { get; set; }
+	/// <inheritdoc />
+	public string ContentType { get; set; }
+	/// <inheritdoc />
+	public bool? DisableDirectStreaming { get; set; }
+	/// <inheritdoc />
+	public bool? DisablePing { get; set; }
+	/// <inheritdoc />
+	public bool? DisableSniff { get; set; }
+	/// <inheritdoc />
+	public bool? EnableHttpPipelining { get; set; } = true;
+	/// <inheritdoc />
+	public Uri ForceNode { get; set; }
+	/// <inheritdoc />
+	public int? MaxRetries { get; set; }
+	/// <inheritdoc />
+	public string OpaqueId { get; set; }
+	/// <inheritdoc />
+	public TimeSpan? PingTimeout { get; set; }
+	/// <inheritdoc />
+	public TimeSpan? RequestTimeout { get; set; }
+	/// <inheritdoc />
+	public string RunAs { get; set; }
+	/// <inheritdoc />
+	public bool? ThrowExceptions { get; set; }
+	/// <inheritdoc />
+	public bool? TransferEncodingChunked { get; set; }
+	/// <inheritdoc />
+	public NameValueCollection Headers { get; set; }
+	/// <inheritdoc />
+	public bool? EnableTcpStats { get; set; }
+	/// <inheritdoc />
+	public bool? EnableThreadPoolStats { get; set; }
+	/// <inheritdoc />
+	public HeadersList ResponseHeadersToParse { get; set; }
+	/// <inheritdoc />
+	public bool? ParseAllHeaders { get; set; }
+
+	/// <inheritdoc />
+	public RequestMetaData RequestMetaData { get; set; }
+}
+
+/// <inheritdoc cref="IRequestConfiguration"/>
+public class RequestConfigurationDescriptor : IRequestConfiguration
+{
+	/// <inheritdoc cref="IRequestConfiguration"/>
+	public RequestConfigurationDescriptor(IRequestConfiguration config)
 	{
-		/// <summary>
-		/// Force a different Accept header on the request
-		/// </summary>
-		string Accept { get; set; }
-
-		/// <summary>
-		/// Treat the following statuses (on top of the 200 range) NOT as error.
-		/// </summary>
-		IReadOnlyCollection<int> AllowedStatusCodes { get; set; }
-
-		/// <summary>
-		/// Provide an authentication header override for this request
-		/// </summary>
-		AuthorizationHeader AuthenticationHeader { get; set; }
-
-		/// <summary>
-		/// Use the following client certificates to authenticate this single request
-		/// </summary>
-		X509CertificateCollection ClientCertificates { get; set; }
-
-		/// <summary>
-		/// Force a different Content-Type header on the request
-		/// </summary>
-		string ContentType { get; set; }
-
-		/// <summary>
-		/// Whether to buffer the request and response bytes for the call
-		/// </summary>
-		bool? DisableDirectStreaming { get; set; }
-
-		/// <summary>
-		/// Under no circumstance do a ping before the actual call. If a node was previously dead a small ping with
-		/// low connect timeout will be tried first in normal circumstances
-		/// </summary>
-		bool? DisablePing { get; set; }
-
-		/// <summary>
-		/// Forces no sniffing to occur on the request no matter what configuration is in place
-		/// globally
-		/// </summary>
-		bool? DisableSniff { get; set; }
-
-		/// <summary>
-		/// Whether or not this request should be pipelined. http://en.wikipedia.org/wiki/HTTP_pipelining defaults to true
-		/// </summary>
-		bool? EnableHttpPipelining { get; set; }
-
-		/// <summary>
-		/// This will force the operation on the specified node, this will bypass any configured connection pool and will no retry.
-		/// </summary>
-		Uri ForceNode { get; set; }
-
-		/// <summary>
-		/// This will override whatever is set on the connection configuration or whatever default the connectionpool has.
-		/// </summary>
-		int? MaxRetries { get; set; }
-
-		/// <summary>
-		/// Associate an Id with this user-initiated task, such that it can be located in the cluster task list.
-		/// Valid only for Elasticsearch 6.2.0+
-		/// </summary>
-		string OpaqueId { get; set; }
-
-		/// <inheritdoc cref="ITransportConfiguration.ParseAllHeaders"/>
-		bool? ParseAllHeaders { get; set; }
-
-		/// <summary>
-		/// The ping timeout for this specific request
-		/// </summary>
-		TimeSpan? PingTimeout { get; set; }
-
-		/// <summary>
-		/// The timeout for this specific request, takes precedence over the global timeout settings
-		/// </summary>
-		TimeSpan? RequestTimeout { get; set; }
-
-		/// <inheritdoc cref="ITransportConfiguration.ResponseHeadersToParse"/>
-		HeadersList ResponseHeadersToParse { get; set; }
-
-		/// <summary>
-		/// Submit the request on behalf in the context of a different shield user
-		/// <pre />https://www.elastic.co/guide/en/shield/current/submitting-requests-for-other-users.html
-		/// </summary>
-		string RunAs { get; set; }
-
-		/// <summary>
-		/// Instead of following a c/go like error checking on response.IsValid do throw an exception (except when <see cref="IApiCallDetails.SuccessOrKnownError"/> is false)
-		/// on the client when a call resulted in an exception on either the client or the Elasticsearch server.
-		/// <para>Reasons for such exceptions could be search parser errors, index missing exceptions, etc...</para>
-		/// </summary>
-		bool? ThrowExceptions { get; set; }
-
-		/// <summary>
-		/// Whether the request should be sent with chunked Transfer-Encoding.
-		/// </summary>
-		bool? TransferEncodingChunked { get; set; }
-
-		/// <summary>
-		/// Try to send these headers for this single request
-		/// </summary>
-		NameValueCollection Headers { get; set; }
-
-		/// <inheritdoc cref="ITransportConfiguration.EnableTcpStats"/>
-		bool? EnableTcpStats { get; set; }
-
-		/// <inheritdoc cref="ITransportConfiguration.EnableThreadPoolStats"/>
-		bool? EnableThreadPoolStats { get; set; }
-
-		/// <summary>
-		/// Holds additional meta data about the request.
-		/// </summary>
-		RequestMetaData RequestMetaData { get; set; }
+		Self.RequestTimeout = config?.RequestTimeout;
+		Self.PingTimeout = config?.PingTimeout;
+		Self.ContentType = config?.ContentType;
+		Self.Accept = config?.Accept;
+		Self.MaxRetries = config?.MaxRetries;
+		Self.ForceNode = config?.ForceNode;
+		Self.DisableSniff = config?.DisableSniff;
+		Self.DisablePing = config?.DisablePing;
+		Self.DisableDirectStreaming = config?.DisableDirectStreaming;
+		Self.AllowedStatusCodes = config?.AllowedStatusCodes;
+		Self.AuthenticationHeader = config?.AuthenticationHeader;
+		Self.EnableHttpPipelining = config?.EnableHttpPipelining ?? true;
+		Self.RunAs = config?.RunAs;
+		Self.ClientCertificates = config?.ClientCertificates;
+		Self.ThrowExceptions = config?.ThrowExceptions;
+		Self.OpaqueId = config?.OpaqueId;
+		Self.TransferEncodingChunked = config?.TransferEncodingChunked;
+		Self.Headers = config?.Headers;
+		Self.EnableTcpStats = config?.EnableTcpStats;
+		Self.EnableThreadPoolStats = config?.EnableThreadPoolStats;
+		Self.ParseAllHeaders = config?.ParseAllHeaders;
+
+		if (config?.ResponseHeadersToParse is not null)
+			Self.ResponseHeadersToParse = config.ResponseHeadersToParse;
 	}
 
-	/// <inheritdoc cref="IRequestConfiguration"/>
-	public class RequestConfiguration : IRequestConfiguration
+	string IRequestConfiguration.Accept { get; set; }
+	IReadOnlyCollection<int> IRequestConfiguration.AllowedStatusCodes { get; set; }
+	AuthorizationHeader IRequestConfiguration.AuthenticationHeader { get; set; }
+	X509CertificateCollection IRequestConfiguration.ClientCertificates { get; set; }
+	string IRequestConfiguration.ContentType { get; set; }
+	bool? IRequestConfiguration.DisableDirectStreaming { get; set; }
+	bool? IRequestConfiguration.DisablePing { get; set; }
+	bool? IRequestConfiguration.DisableSniff { get; set; }
+	bool? IRequestConfiguration.EnableHttpPipelining { get; set; } = true;
+	Uri IRequestConfiguration.ForceNode { get; set; }
+	int? IRequestConfiguration.MaxRetries { get; set; }
+	string IRequestConfiguration.OpaqueId { get; set; }
+	TimeSpan? IRequestConfiguration.PingTimeout { get; set; }
+	TimeSpan? IRequestConfiguration.RequestTimeout { get; set; }
+	string IRequestConfiguration.RunAs { get; set; }
+	private IRequestConfiguration Self => this;
+	bool? IRequestConfiguration.ThrowExceptions { get; set; }
+	bool? IRequestConfiguration.TransferEncodingChunked { get; set; }
+	NameValueCollection IRequestConfiguration.Headers { get; set; }
+	bool? IRequestConfiguration.EnableTcpStats { get; set; }
+	bool? IRequestConfiguration.EnableThreadPoolStats { get; set; }
+	HeadersList IRequestConfiguration.ResponseHeadersToParse { get; set; }
+	bool? IRequestConfiguration.ParseAllHeaders { get; set; }
+	RequestMetaData IRequestConfiguration.RequestMetaData { get; set; }
+
+
+	/// <inheritdoc cref="IRequestConfiguration.RunAs"/>
+	public RequestConfigurationDescriptor RunAs(string username)
 	{
-		/// <inheritdoc />
-		public string Accept { get; set; }
-		/// <inheritdoc />
-		public IReadOnlyCollection<int> AllowedStatusCodes { get; set; }
-		/// <inheritdoc />
-		public AuthorizationHeader AuthenticationHeader { get; set; }
-		/// <inheritdoc />
-		public X509CertificateCollection ClientCertificates { get; set; }
-		/// <inheritdoc />
-		public string ContentType { get; set; }
-		/// <inheritdoc />
-		public bool? DisableDirectStreaming { get; set; }
-		/// <inheritdoc />
-		public bool? DisablePing { get; set; }
-		/// <inheritdoc />
-		public bool? DisableSniff { get; set; }
-		/// <inheritdoc />
-		public bool? EnableHttpPipelining { get; set; } = true;
-		/// <inheritdoc />
-		public Uri ForceNode { get; set; }
-		/// <inheritdoc />
-		public int? MaxRetries { get; set; }
-		/// <inheritdoc />
-		public string OpaqueId { get; set; }
-		/// <inheritdoc />
-		public TimeSpan? PingTimeout { get; set; }
-		/// <inheritdoc />
-		public TimeSpan? RequestTimeout { get; set; }
-		/// <inheritdoc />
-		public string RunAs { get; set; }
-		/// <inheritdoc />
-		public bool? ThrowExceptions { get; set; }
-		/// <inheritdoc />
-		public bool? TransferEncodingChunked { get; set; }
-		/// <inheritdoc />
-		public NameValueCollection Headers { get; set; }
-		/// <inheritdoc />
-		public bool? EnableTcpStats { get; set; }
-		/// <inheritdoc />
-		public bool? EnableThreadPoolStats { get; set; }
-		/// <inheritdoc />
-		public HeadersList ResponseHeadersToParse { get; set; }
-		/// <inheritdoc />
-		public bool? ParseAllHeaders { get; set; }
-
-		/// <inheritdoc />
-		public RequestMetaData RequestMetaData { get; set; }
+		Self.RunAs = username;
+		return this;
 	}
 
-	/// <inheritdoc cref="IRequestConfiguration"/>
-	public class RequestConfigurationDescriptor : IRequestConfiguration
+	/// <inheritdoc cref="IRequestConfiguration.RequestTimeout"/>
+	public RequestConfigurationDescriptor RequestTimeout(TimeSpan requestTimeout)
+	{
+		Self.RequestTimeout = requestTimeout;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.OpaqueId"/>
+	public RequestConfigurationDescriptor OpaqueId(string opaqueId)
+	{
+		Self.OpaqueId = opaqueId;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.PingTimeout"/>
+	public RequestConfigurationDescriptor PingTimeout(TimeSpan pingTimeout)
+	{
+		Self.PingTimeout = pingTimeout;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.ContentType"/>
+	public RequestConfigurationDescriptor ContentType(string contentTypeHeader)
+	{
+		Self.ContentType = contentTypeHeader;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.Accept"/>
+	public RequestConfigurationDescriptor Accept(string acceptHeader)
+	{
+		Self.Accept = acceptHeader;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.AllowedStatusCodes"/>
+	public RequestConfigurationDescriptor AllowedStatusCodes(IEnumerable<int> codes)
+	{
+		Self.AllowedStatusCodes = codes?.ToReadOnlyCollection();
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.AllowedStatusCodes"/>
+	public RequestConfigurationDescriptor AllowedStatusCodes(params int[] codes)
+	{
+		Self.AllowedStatusCodes = codes?.ToReadOnlyCollection();
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.DisableSniff"/>
+	public RequestConfigurationDescriptor DisableSniffing(bool? disable = true)
+	{
+		Self.DisableSniff = disable;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.DisablePing"/>
+	public RequestConfigurationDescriptor DisablePing(bool? disable = true)
+	{
+		Self.DisablePing = disable;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.ThrowExceptions"/>
+	public RequestConfigurationDescriptor ThrowExceptions(bool throwExceptions = true)
+	{
+		Self.ThrowExceptions = throwExceptions;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.DisableDirectStreaming"/>
+	public RequestConfigurationDescriptor DisableDirectStreaming(bool? disable = true)
+	{
+		Self.DisableDirectStreaming = disable;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.ForceNode"/>
+	public RequestConfigurationDescriptor ForceNode(Uri uri)
+	{
+		Self.ForceNode = uri;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.MaxRetries"/>
+	public RequestConfigurationDescriptor MaxRetries(int retry)
+	{
+		Self.MaxRetries = retry;
+		return this;
+	}
+
+	/// <inheritdoc cref="AuthorizationHeader"/>
+	public RequestConfigurationDescriptor Authentication(AuthorizationHeader authentication)
+	{
+		Self.AuthenticationHeader = authentication;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.EnableHttpPipelining"/>
+	public RequestConfigurationDescriptor EnableHttpPipelining(bool enable = true)
+	{
+		Self.EnableHttpPipelining = enable;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.ClientCertificates"/>
+	public RequestConfigurationDescriptor ClientCertificates(X509CertificateCollection certificates)
+	{
+		Self.ClientCertificates = certificates;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.ClientCertificates"/>
+	public RequestConfigurationDescriptor ClientCertificate(X509Certificate certificate) =>
+		ClientCertificates(new X509Certificate2Collection { certificate });
+
+	/// <inheritdoc cref="IRequestConfiguration.ClientCertificates"/>
+	public RequestConfigurationDescriptor ClientCertificate(string certificatePath) =>
+		ClientCertificates(new X509Certificate2Collection { new X509Certificate(certificatePath) });
+
+	/// <inheritdoc cref="IRequestConfiguration.TransferEncodingChunked" />
+	public RequestConfigurationDescriptor TransferEncodingChunked(bool? transferEncodingChunked = true)
+	{
+		Self.TransferEncodingChunked = transferEncodingChunked;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.Headers" />
+	public RequestConfigurationDescriptor GlobalHeaders(NameValueCollection headers)
+	{
+		Self.Headers = headers;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.EnableTcpStats" />
+	public RequestConfigurationDescriptor EnableTcpStats(bool? enableTcpStats = true)
+	{
+		Self.EnableTcpStats = enableTcpStats;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.EnableThreadPoolStats" />
+	public RequestConfigurationDescriptor EnableThreadPoolStats(bool? enableThreadPoolStats = true)
+	{
+		Self.EnableThreadPoolStats = enableThreadPoolStats;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.ParseAllHeaders"/>
+	public RequestConfigurationDescriptor ParseAllHeaders(bool? enable = true)
+	{
+		Self.ParseAllHeaders = enable;
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.ResponseHeadersToParse"/>
+	public RequestConfigurationDescriptor ResponseHeadersToParse(IEnumerable<string> headers)
+	{
+		Self.ResponseHeadersToParse = new HeadersList(headers);
+		return this;
+	}
+
+	/// <inheritdoc cref="IRequestConfiguration.RequestMetaData" />
+	public RequestConfigurationDescriptor RequestMetaData(RequestMetaData metaData)
 	{
-		/// <inheritdoc cref="IRequestConfiguration"/>
-		public RequestConfigurationDescriptor(IRequestConfiguration config)
-		{
-			Self.RequestTimeout = config?.RequestTimeout;
-			Self.PingTimeout = config?.PingTimeout;
-			Self.ContentType = config?.ContentType;
-			Self.Accept = config?.Accept;
-			Self.MaxRetries = config?.MaxRetries;
-			Self.ForceNode = config?.ForceNode;
-			Self.DisableSniff = config?.DisableSniff;
-			Self.DisablePing = config?.DisablePing;
-			Self.DisableDirectStreaming = config?.DisableDirectStreaming;
-			Self.AllowedStatusCodes = config?.AllowedStatusCodes;
-			Self.AuthenticationHeader = config?.AuthenticationHeader;
-			Self.EnableHttpPipelining = config?.EnableHttpPipelining ?? true;
-			Self.RunAs = config?.RunAs;
-			Self.ClientCertificates = config?.ClientCertificates;
-			Self.ThrowExceptions = config?.ThrowExceptions;
-			Self.OpaqueId = config?.OpaqueId;
-			Self.TransferEncodingChunked = config?.TransferEncodingChunked;
-			Self.Headers = config?.Headers;
-			Self.EnableTcpStats = config?.EnableTcpStats;
-			Self.EnableThreadPoolStats = config?.EnableThreadPoolStats;
-			Self.ParseAllHeaders = config?.ParseAllHeaders;
-
-			if (config?.ResponseHeadersToParse is not null)
-				Self.ResponseHeadersToParse = config.ResponseHeadersToParse;
-		}
-
-		string IRequestConfiguration.Accept { get; set; }
-		IReadOnlyCollection<int> IRequestConfiguration.AllowedStatusCodes { get; set; }
-		AuthorizationHeader IRequestConfiguration.AuthenticationHeader { get; set; }
-		X509CertificateCollection IRequestConfiguration.ClientCertificates { get; set; }
-		string IRequestConfiguration.ContentType { get; set; }
-		bool? IRequestConfiguration.DisableDirectStreaming { get; set; }
-		bool? IRequestConfiguration.DisablePing { get; set; }
-		bool? IRequestConfiguration.DisableSniff { get; set; }
-		bool? IRequestConfiguration.EnableHttpPipelining { get; set; } = true;
-		Uri IRequestConfiguration.ForceNode { get; set; }
-		int? IRequestConfiguration.MaxRetries { get; set; }
-		string IRequestConfiguration.OpaqueId { get; set; }
-		TimeSpan? IRequestConfiguration.PingTimeout { get; set; }
-		TimeSpan? IRequestConfiguration.RequestTimeout { get; set; }
-		string IRequestConfiguration.RunAs { get; set; }
-		private IRequestConfiguration Self => this;
-		bool? IRequestConfiguration.ThrowExceptions { get; set; }
-		bool? IRequestConfiguration.TransferEncodingChunked { get; set; }
-		NameValueCollection IRequestConfiguration.Headers { get; set; }
-		bool? IRequestConfiguration.EnableTcpStats { get; set; }
-		bool? IRequestConfiguration.EnableThreadPoolStats { get; set; }
-		HeadersList IRequestConfiguration.ResponseHeadersToParse { get; set; }
-		bool? IRequestConfiguration.ParseAllHeaders { get; set; }
-		RequestMetaData IRequestConfiguration.RequestMetaData { get; set; }
-
-
-		/// <inheritdoc cref="IRequestConfiguration.RunAs"/>
-		public RequestConfigurationDescriptor RunAs(string username)
-		{
-			Self.RunAs = username;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.RequestTimeout"/>
-		public RequestConfigurationDescriptor RequestTimeout(TimeSpan requestTimeout)
-		{
-			Self.RequestTimeout = requestTimeout;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.OpaqueId"/>
-		public RequestConfigurationDescriptor OpaqueId(string opaqueId)
-		{
-			Self.OpaqueId = opaqueId;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.PingTimeout"/>
-		public RequestConfigurationDescriptor PingTimeout(TimeSpan pingTimeout)
-		{
-			Self.PingTimeout = pingTimeout;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.ContentType"/>
-		public RequestConfigurationDescriptor ContentType(string contentTypeHeader)
-		{
-			Self.ContentType = contentTypeHeader;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.Accept"/>
-		public RequestConfigurationDescriptor Accept(string acceptHeader)
-		{
-			Self.Accept = acceptHeader;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.AllowedStatusCodes"/>
-		public RequestConfigurationDescriptor AllowedStatusCodes(IEnumerable<int> codes)
-		{
-			Self.AllowedStatusCodes = codes?.ToReadOnlyCollection();
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.AllowedStatusCodes"/>
-		public RequestConfigurationDescriptor AllowedStatusCodes(params int[] codes)
-		{
-			Self.AllowedStatusCodes = codes?.ToReadOnlyCollection();
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.DisableSniff"/>
-		public RequestConfigurationDescriptor DisableSniffing(bool? disable = true)
-		{
-			Self.DisableSniff = disable;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.DisablePing"/>
-		public RequestConfigurationDescriptor DisablePing(bool? disable = true)
-		{
-			Self.DisablePing = disable;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.ThrowExceptions"/>
-		public RequestConfigurationDescriptor ThrowExceptions(bool throwExceptions = true)
-		{
-			Self.ThrowExceptions = throwExceptions;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.DisableDirectStreaming"/>
-		public RequestConfigurationDescriptor DisableDirectStreaming(bool? disable = true)
-		{
-			Self.DisableDirectStreaming = disable;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.ForceNode"/>
-		public RequestConfigurationDescriptor ForceNode(Uri uri)
-		{
-			Self.ForceNode = uri;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.MaxRetries"/>
-		public RequestConfigurationDescriptor MaxRetries(int retry)
-		{
-			Self.MaxRetries = retry;
-			return this;
-		}
-
-		/// <inheritdoc cref="AuthorizationHeader"/>
-		public RequestConfigurationDescriptor Authentication(AuthorizationHeader authentication)
-		{
-			Self.AuthenticationHeader = authentication;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.EnableHttpPipelining"/>
-		public RequestConfigurationDescriptor EnableHttpPipelining(bool enable = true)
-		{
-			Self.EnableHttpPipelining = enable;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.ClientCertificates"/>
-		public RequestConfigurationDescriptor ClientCertificates(X509CertificateCollection certificates)
-		{
-			Self.ClientCertificates = certificates;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.ClientCertificates"/>
-		public RequestConfigurationDescriptor ClientCertificate(X509Certificate certificate) =>
-			ClientCertificates(new X509Certificate2Collection { certificate });
-
-		/// <inheritdoc cref="IRequestConfiguration.ClientCertificates"/>
-		public RequestConfigurationDescriptor ClientCertificate(string certificatePath) =>
-			ClientCertificates(new X509Certificate2Collection { new X509Certificate(certificatePath) });
-
-		/// <inheritdoc cref="IRequestConfiguration.TransferEncodingChunked" />
-		public RequestConfigurationDescriptor TransferEncodingChunked(bool? transferEncodingChunked = true)
-		{
-			Self.TransferEncodingChunked = transferEncodingChunked;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.Headers" />
-		public RequestConfigurationDescriptor GlobalHeaders(NameValueCollection headers)
-		{
-			Self.Headers = headers;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.EnableTcpStats" />
-		public RequestConfigurationDescriptor EnableTcpStats(bool? enableTcpStats = true)
-		{
-			Self.EnableTcpStats = enableTcpStats;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.EnableThreadPoolStats" />
-		public RequestConfigurationDescriptor EnableThreadPoolStats(bool? enableThreadPoolStats = true)
-		{
-			Self.EnableThreadPoolStats = enableThreadPoolStats;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.ParseAllHeaders"/>
-		public RequestConfigurationDescriptor ParseAllHeaders(bool? enable = true)
-		{
-			Self.ParseAllHeaders = enable;
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.ResponseHeadersToParse"/>
-		public RequestConfigurationDescriptor ResponseHeadersToParse(IEnumerable<string> headers)
-		{
-			Self.ResponseHeadersToParse = new HeadersList(headers);
-			return this;
-		}
-
-		/// <inheritdoc cref="IRequestConfiguration.RequestMetaData" />
-		public RequestConfigurationDescriptor RequestMetaData(RequestMetaData metaData)
-		{
-			Self.RequestMetaData = metaData;
-			return this;
-		}
+		Self.RequestMetaData = metaData;
+		return this;
 	}
 }
diff --git a/src/Elastic.Transport/Configuration/Security/ApiKey.cs b/src/Elastic.Transport/Configuration/Security/ApiKey.cs
index f068a44..801bfa3 100644
--- a/src/Elastic.Transport/Configuration/Security/ApiKey.cs
+++ b/src/Elastic.Transport/Configuration/Security/ApiKey.cs
@@ -2,26 +2,25 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Credentials for Api Key Authentication
+/// </summary>
+public sealed class ApiKey : AuthorizationHeader
 {
-	/// <summary>
-	/// Credentials for Api Key Authentication
-	/// </summary>
-	public sealed class ApiKey : AuthorizationHeader
-	{
-		private readonly string _apiKey;
+	private readonly string _apiKey;
 
-		/// <inheritdoc cref="Base64ApiKey"/>
-		public ApiKey(string apiKey) => _apiKey = apiKey;
+	/// <inheritdoc cref="Base64ApiKey"/>
+	public ApiKey(string apiKey) => _apiKey = apiKey;
 
-		/// <inheritdoc cref="AuthorizationHeader.AuthScheme"/>
-		public override string AuthScheme { get; } = "ApiKey";
+	/// <inheritdoc cref="AuthorizationHeader.AuthScheme"/>
+	public override string AuthScheme { get; } = "ApiKey";
 
-		/// <inheritdoc cref="AuthorizationHeader.TryGetAuthorizationParameters(out string)"/>
-		public override bool TryGetAuthorizationParameters(out string value)
-		{
-			value = _apiKey;
-			return true;
-		}
+	/// <inheritdoc cref="AuthorizationHeader.TryGetAuthorizationParameters(out string)"/>
+	public override bool TryGetAuthorizationParameters(out string value)
+	{
+		value = _apiKey;
+		return true;
 	}
 }
diff --git a/src/Elastic.Transport/Configuration/Security/AuthorizationHeader.cs b/src/Elastic.Transport/Configuration/Security/AuthorizationHeader.cs
index 83aa591..a93c708 100644
--- a/src/Elastic.Transport/Configuration/Security/AuthorizationHeader.cs
+++ b/src/Elastic.Transport/Configuration/Security/AuthorizationHeader.cs
@@ -2,21 +2,20 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// The HTTP authorization request header used to provide credentials that authenticate a user agent with a server.
+/// </summary>
+public abstract class AuthorizationHeader
 {
 	/// <summary>
-	/// The HTTP authorization request header used to provide credentials that authenticate a user agent with a server.
+	/// The authentication scheme that defines how the credentials are encoded.
 	/// </summary>
-	public abstract class AuthorizationHeader
-	{
-		/// <summary>
-		/// The authentication scheme that defines how the credentials are encoded.
-		/// </summary>
-		public abstract string AuthScheme { get; }
+	public abstract string AuthScheme { get; }
 
-		/// <summary>
-		/// If this instance is valid, returns the authorization parameters to include in the header.
-		/// </summary>
-		public abstract bool TryGetAuthorizationParameters(out string value);
-	}
+	/// <summary>
+	/// If this instance is valid, returns the authorization parameters to include in the header.
+	/// </summary>
+	public abstract bool TryGetAuthorizationParameters(out string value);
 }
diff --git a/src/Elastic.Transport/Configuration/Security/Base64ApiKey.cs b/src/Elastic.Transport/Configuration/Security/Base64ApiKey.cs
index 5e44805..84090bf 100644
--- a/src/Elastic.Transport/Configuration/Security/Base64ApiKey.cs
+++ b/src/Elastic.Transport/Configuration/Security/Base64ApiKey.cs
@@ -5,31 +5,30 @@
 using System;
 using System.Text;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Credentials for Api Key Authentication
+/// </summary>
+public sealed class Base64ApiKey : AuthorizationHeader
 {
-	/// <summary>
-	/// Credentials for Api Key Authentication
-	/// </summary>
-	public sealed class Base64ApiKey : AuthorizationHeader
-	{
-		private readonly string _base64String;
+	private readonly string _base64String;
 
-		/// <inheritdoc cref="Base64ApiKey"/>
-		public Base64ApiKey(string id, string apiKey) =>
-			_base64String = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{id}:{apiKey}"));
+	/// <inheritdoc cref="Base64ApiKey"/>
+	public Base64ApiKey(string id, string apiKey) =>
+		_base64String = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{id}:{apiKey}"));
 
-		/// <inheritdoc cref="Base64ApiKey"/>
-		public Base64ApiKey(string base64EncodedApiKey) =>
-			_base64String = base64EncodedApiKey;
+	/// <inheritdoc cref="Base64ApiKey"/>
+	public Base64ApiKey(string base64EncodedApiKey) =>
+		_base64String = base64EncodedApiKey;
 
-		/// <inheritdoc cref="AuthorizationHeader.AuthScheme"/>
-		public override string AuthScheme { get; } = "ApiKey";
+	/// <inheritdoc cref="AuthorizationHeader.AuthScheme"/>
+	public override string AuthScheme { get; } = "ApiKey";
 
-		/// <inheritdoc cref="AuthorizationHeader.TryGetAuthorizationParameters(out string)"/>
-		public override bool TryGetAuthorizationParameters(out string value)
-		{
-			value = _base64String;
-			return true;
-		}
+	/// <inheritdoc cref="AuthorizationHeader.TryGetAuthorizationParameters(out string)"/>
+	public override bool TryGetAuthorizationParameters(out string value)
+	{
+		value = _base64String;
+		return true;
 	}
 }
diff --git a/src/Elastic.Transport/Configuration/Security/BasicAuthenticationCredentials.cs b/src/Elastic.Transport/Configuration/Security/BasicAuthenticationCredentials.cs
index 1c997c3..44d126c 100644
--- a/src/Elastic.Transport/Configuration/Security/BasicAuthenticationCredentials.cs
+++ b/src/Elastic.Transport/Configuration/Security/BasicAuthenticationCredentials.cs
@@ -5,34 +5,33 @@
 using System;
 using System.Text;
 
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// Credentials for Basic Authentication.
-	/// </summary>
-	public sealed class BasicAuthentication : AuthorizationHeader
-	{
-		private readonly string _base64String;
+namespace Elastic.Transport;
 
-		/// <summary> The default http header used for basic authentication </summary>
-		public static string BasicAuthenticationScheme { get; } = "Basic";
+/// <summary>
+/// Credentials for Basic Authentication.
+/// </summary>
+public sealed class BasicAuthentication : AuthorizationHeader
+{
+	private readonly string _base64String;
 
-		/// <inheritdoc cref="BasicAuthentication"/>
-		public BasicAuthentication(string username, string password) =>
-			_base64String = GetBase64String($"{username}:{password}");
+	/// <summary> The default http header used for basic authentication </summary>
+	public static string BasicAuthenticationScheme { get; } = "Basic";
 
-		/// <inheritdoc cref="AuthorizationHeader.AuthScheme"/>
-		public override string AuthScheme { get; } = BasicAuthenticationScheme;
+	/// <inheritdoc cref="BasicAuthentication"/>
+	public BasicAuthentication(string username, string password) =>
+		_base64String = GetBase64String($"{username}:{password}");
 
-		/// <inheritdoc cref="AuthorizationHeader.TryGetAuthorizationParameters(out string)"/>
-		public override bool TryGetAuthorizationParameters(out string value)
-		{
-			value = _base64String;
-			return true;
-		}
+	/// <inheritdoc cref="AuthorizationHeader.AuthScheme"/>
+	public override string AuthScheme { get; } = BasicAuthenticationScheme;
 
-		/// <summary> Get Base64 representation for string </summary>
-		public static string GetBase64String(string header) =>
-			Convert.ToBase64String(Encoding.UTF8.GetBytes(header));
+	/// <inheritdoc cref="AuthorizationHeader.TryGetAuthorizationParameters(out string)"/>
+	public override bool TryGetAuthorizationParameters(out string value)
+	{
+		value = _base64String;
+		return true;
 	}
+
+	/// <summary> Get Base64 representation for string </summary>
+	public static string GetBase64String(string header) =>
+		Convert.ToBase64String(Encoding.UTF8.GetBytes(header));
 }
diff --git a/src/Elastic.Transport/Configuration/TransportConfiguration.cs b/src/Elastic.Transport/Configuration/TransportConfiguration.cs
index b49c793..de3dfa5 100644
--- a/src/Elastic.Transport/Configuration/TransportConfiguration.cs
+++ b/src/Elastic.Transport/Configuration/TransportConfiguration.cs
@@ -19,464 +19,462 @@
 using Elastic.Transport.Extensions;
 using Elastic.Transport.Products;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Allows you to control how <see cref="HttpTransport{TConnectionSettings}"/> behaves and where/how it connects to Elastic Stack products
+/// </summary>
+public class TransportConfiguration : TransportConfigurationBase<TransportConfiguration>
 {
 	/// <summary>
-	/// Allows you to control how <see cref="ITransport{TConnectionSettings}"/> behaves and where/how it connects to Elastic Stack products
+	/// Detects whether we are running on .NET Core with CurlHandler.
+	/// If this is true, we will set a very restrictive <see cref="DefaultConnectionLimit"/>
+	/// As the old curl based handler is known to bleed TCP connections:
+	/// <para>https://github.com/dotnet/runtime/issues/22366</para>
 	/// </summary>
-	public class TransportConfiguration : TransportConfigurationBase<TransportConfiguration>
-	{
-		/// <summary>
-		/// Detects whether we are running on .NET Core with CurlHandler.
-		/// If this is true, we will set a very restrictive <see cref="DefaultConnectionLimit"/>
-		/// As the old curl based handler is known to bleed TCP connections:
-		/// <para>https://github.com/dotnet/runtime/issues/22366</para>
-		/// </summary>
-		private static bool UsingCurlHandler => ConnectionInfo.UsingCurlHandler;
-
-		//public static IMemoryStreamFactory Default { get; } = RecyclableMemoryStreamFactory.Default;
-		// ReSharper disable once RedundantNameQualifier
-		/// <summary>
-		/// The default memory stream factory if none is configured on <see cref="ITransportConfiguration.MemoryStreamFactory"/>
-		/// </summary>
-		public static IMemoryStreamFactory DefaultMemoryStreamFactory { get; } = Elastic.Transport.MemoryStreamFactory.Default;
-
-		/// <summary>
-		/// The default ping timeout. Defaults to 2 seconds
-		/// </summary>
-		public static readonly TimeSpan DefaultPingTimeout = TimeSpan.FromSeconds(2);
-
-		/// <summary>
-		/// The default ping timeout when the connection is over HTTPS. Defaults to
-		/// 5 seconds
-		/// </summary>
-		public static readonly TimeSpan DefaultPingTimeoutOnSsl = TimeSpan.FromSeconds(5);
-
-		/// <summary>
-		/// The default timeout before the client aborts a request to Elasticsearch.
-		/// Defaults to 1 minute
-		/// </summary>
-		public static readonly TimeSpan DefaultTimeout = TimeSpan.FromMinutes(1);
-
-		/// <summary>
-		/// The default timeout before a TCP connection is forcefully recycled so that DNS updates come through
-		/// Defaults to 5 minutes.
-		/// </summary>
-		public static readonly TimeSpan DefaultDnsRefreshTimeout = TimeSpan.FromMinutes(5);
+	private static bool UsingCurlHandler => ConnectionInfo.UsingCurlHandler;
+
+	//public static MemoryStreamFactory Default { get; } = RecyclableMemoryStreamFactory.Default;
+	// ReSharper disable once RedundantNameQualifier
+	/// <summary>
+	/// The default memory stream factory if none is configured on <see cref="ITransportConfiguration.MemoryStreamFactory"/>
+	/// </summary>
+	public static MemoryStreamFactory DefaultMemoryStreamFactory { get; } = Elastic.Transport.DefaultMemoryStreamFactory.Default;
+
+	/// <summary>
+	/// The default ping timeout. Defaults to 2 seconds
+	/// </summary>
+	public static readonly TimeSpan DefaultPingTimeout = TimeSpan.FromSeconds(2);
+
+	/// <summary>
+	/// The default ping timeout when the connection is over HTTPS. Defaults to
+	/// 5 seconds
+	/// </summary>
+	public static readonly TimeSpan DefaultPingTimeoutOnSsl = TimeSpan.FromSeconds(5);
+
+	/// <summary>
+	/// The default timeout before the client aborts a request to Elasticsearch.
+	/// Defaults to 1 minute
+	/// </summary>
+	public static readonly TimeSpan DefaultTimeout = TimeSpan.FromMinutes(1);
+
+	/// <summary>
+	/// The default timeout before a TCP connection is forcefully recycled so that DNS updates come through
+	/// Defaults to 5 minutes.
+	/// </summary>
+	public static readonly TimeSpan DefaultDnsRefreshTimeout = TimeSpan.FromMinutes(5);
 
 #pragma warning disable 1587
 #pragma warning disable 1570
-		/// <summary>
-		/// The default concurrent connection limit for outgoing http requests. Defaults to <c>80</c>
+	/// <summary>
+	/// The default concurrent connection limit for outgoing http requests. Defaults to <c>80</c>
 #if DOTNETCORE
-		/// <para>Except for <see cref="HttpClientHandler"/> implementations based on curl, which defaults to <see cref="Environment.ProcessorCount"/></para>
+	/// <para>Except for <see cref="HttpClientHandler"/> implementations based on curl, which defaults to <see cref="Environment.ProcessorCount"/></para>
 #endif
-		/// </summary>
+	/// </summary>
 #pragma warning restore 1570
 #pragma warning restore 1587
-		public static readonly int DefaultConnectionLimit = UsingCurlHandler ? Environment.ProcessorCount : 80;
-
-		/// <summary>
-		/// Creates a new instance of <see cref="TransportConfiguration"/>
-		/// </summary>
-		/// <param name="uri">The root of the Elastic stack product node we want to connect to. Defaults to http://localhost:9200</param>
-		/// <param name="productRegistration"><inheritdoc cref="IProductRegistration" path="/summary"/></param>
-		public TransportConfiguration(Uri uri = null, IProductRegistration productRegistration = null)
-			: this(new SingleNodePool(uri ?? new Uri("http://localhost:9200")), productRegistration: productRegistration) { }
-
-		/// <summary>
-		/// Sets up the client to communicate to Elastic Cloud using <paramref name="cloudId"/>,
-		/// <para><see cref="CloudNodePool"/> documentation for more information on how to obtain your Cloud Id</para>
-		/// </summary>
-		public TransportConfiguration(string cloudId, BasicAuthentication credentials, IProductRegistration productRegistration = null)
-			: this(new CloudNodePool(cloudId, credentials), productRegistration: productRegistration) { }
-
-		/// <summary>
-		/// Sets up the client to communicate to Elastic Cloud using <paramref name="cloudId"/>,
-		/// <para><see cref="CloudNodePool"/> documentation for more information on how to obtain your Cloud Id</para>
-		/// </summary>
-		public TransportConfiguration(string cloudId, Base64ApiKey credentials, IProductRegistration productRegistration = null)
-			: this(new CloudNodePool(cloudId, credentials), productRegistration: productRegistration) { }
-
-		/// <summary> <inheritdoc cref="TransportConfiguration" path="/summary"/></summary>
-		/// <param name="nodePool"><inheritdoc cref="NodePool" path="/summary"/></param>
-		/// <param name="connection"><inheritdoc cref="ITransportClient" path="/summary"/></param>
-		/// <param name="serializer"><inheritdoc cref="Serializer" path="/summary"/></param>
-		/// <param name="productRegistration"><inheritdoc cref="IProductRegistration" path="/summary"/></param>
-		public TransportConfiguration(
-			NodePool nodePool,
-			ITransportClient connection = null,
-			Serializer serializer = null,
-			IProductRegistration productRegistration = null)
-			: base(nodePool, connection, serializer, productRegistration) { }
+	public static readonly int DefaultConnectionLimit = UsingCurlHandler ? Environment.ProcessorCount : 80;
 
-	}
+	/// <summary>
+	/// Creates a new instance of <see cref="TransportConfiguration"/>
+	/// </summary>
+	/// <param name="uri">The root of the Elastic stack product node we want to connect to. Defaults to http://localhost:9200</param>
+	/// <param name="productRegistration"><inheritdoc cref="ProductRegistration" path="/summary"/></param>
+	public TransportConfiguration(Uri uri = null, ProductRegistration productRegistration = null)
+		: this(new SingleNodePool(uri ?? new Uri("http://localhost:9200")), productRegistration: productRegistration) { }
+
+	/// <summary>
+	/// Sets up the client to communicate to Elastic Cloud using <paramref name="cloudId"/>,
+	/// <para><see cref="CloudNodePool"/> documentation for more information on how to obtain your Cloud Id</para>
+	/// </summary>
+	public TransportConfiguration(string cloudId, BasicAuthentication credentials, ProductRegistration productRegistration = null)
+		: this(new CloudNodePool(cloudId, credentials), productRegistration: productRegistration) { }
+
+	/// <summary>
+	/// Sets up the client to communicate to Elastic Cloud using <paramref name="cloudId"/>,
+	/// <para><see cref="CloudNodePool"/> documentation for more information on how to obtain your Cloud Id</para>
+	/// </summary>
+	public TransportConfiguration(string cloudId, Base64ApiKey credentials, ProductRegistration productRegistration = null)
+		: this(new CloudNodePool(cloudId, credentials), productRegistration: productRegistration) { }
+
+	/// <summary> <inheritdoc cref="TransportConfiguration" path="/summary"/></summary>
+	/// <param name="nodePool"><inheritdoc cref="NodePool" path="/summary"/></param>
+	/// <param name="connection"><inheritdoc cref="TransportClient" path="/summary"/></param>
+	/// <param name="serializer"><inheritdoc cref="Serializer" path="/summary"/></param>
+	/// <param name="productRegistration"><inheritdoc cref="ProductRegistration" path="/summary"/></param>
+	public TransportConfiguration(
+		NodePool nodePool,
+		TransportClient connection = null,
+		Serializer serializer = null,
+		ProductRegistration productRegistration = null)
+		: base(nodePool, connection, serializer, productRegistration) { }
+
+}
 
-	/// <inheritdoc cref="TransportConfiguration"/>>
-	[Browsable(false)]
-	[EditorBrowsable(EditorBrowsableState.Never)]
-	public abstract class TransportConfigurationBase<T> : ITransportConfiguration
-		where T : TransportConfigurationBase<T>
+/// <inheritdoc cref="TransportConfiguration"/>>
+[Browsable(false)]
+[EditorBrowsable(EditorBrowsableState.Never)]
+public abstract class TransportConfigurationBase<T> : ITransportConfiguration
+	where T : TransportConfigurationBase<T>
+{
+	private readonly TransportClient _transportClient;
+	private readonly NodePool _nodePool;
+	private readonly ProductRegistration _productRegistration;
+	private readonly NameValueCollection _headers = new NameValueCollection();
+	private readonly NameValueCollection _queryString = new NameValueCollection();
+	private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
+	private readonly UrlFormatter _urlFormatter;
+
+	private AuthorizationHeader _authenticationHeader;
+	private X509CertificateCollection _clientCertificates;
+	private Action<ApiCallDetails> _completedRequestHandler = DefaultCompletedRequestHandler;
+	private int _transportClientLimit;
+	private TimeSpan? _deadTimeout;
+	private bool _disableAutomaticProxyDetection;
+	private bool _disableDirectStreaming;
+	private bool _disablePings;
+	private bool _enableHttpCompression;
+	private bool _enableHttpPipelining = true;
+	private TimeSpan? _keepAliveInterval;
+	private TimeSpan? _keepAliveTime;
+	private TimeSpan? _maxDeadTimeout;
+	private int? _maxRetries;
+	private TimeSpan? _maxRetryTimeout;
+	private Func<Node, bool> _nodePredicate;
+	private Action<RequestData> _onRequestDataCreated = DefaultRequestDataCreated;
+	private TimeSpan? _pingTimeout;
+	private string _proxyAddress;
+	private string _proxyPassword;
+	private string _proxyUsername;
+	private TimeSpan _requestTimeout;
+	private TimeSpan _dnsRefreshTimeout;
+	private Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> _serverCertificateValidationCallback;
+	private IReadOnlyCollection<int> _skipDeserializationForStatusCodes = new ReadOnlyCollection<int>(new int[] { });
+	private TimeSpan? _sniffLifeSpan;
+	private bool _sniffOnConnectionFault;
+	private bool _sniffOnStartup;
+	private bool _throwExceptions;
+	private bool _transferEncodingChunked;
+	private MemoryStreamFactory _memoryStreamFactory;
+	private bool _enableTcpStats;
+	private bool _enableThreadPoolStats;
+	private UserAgent _userAgent;
+	private string _certificateFingerprint;
+	private bool _disableMetaHeader;
+	private readonly MetaHeaderProvider _metaHeaderProvider;
+
+	private readonly Func<HttpMethod, int, bool> _statusCodeToResponseSuccess;
+
+	/// <summary>
+	/// <inheritdoc cref="TransportConfiguration"/>
+	/// </summary>
+	/// <param name="nodePool"><inheritdoc cref="NodePool" path="/summary"/></param>
+	/// <param name="transportClient"><inheritdoc cref="TransportClient" path="/summary"/></param>
+	/// <param name="requestResponseSerializer"><inheritdoc cref="Serializer" path="/summary"/></param>
+	/// <param name="productRegistration"><inheritdoc cref="ProductRegistration" path="/summary"/></param>
+	protected TransportConfigurationBase(NodePool nodePool, TransportClient transportClient, Serializer requestResponseSerializer, ProductRegistration productRegistration)
 	{
-		private readonly ITransportClient _transportClient;
-		private readonly NodePool _nodePool;
-		private readonly IProductRegistration _productRegistration;
-		private readonly NameValueCollection _headers = new NameValueCollection();
-		private readonly NameValueCollection _queryString = new NameValueCollection();
-		private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
-		private readonly UrlFormatter _urlFormatter;
-
-		private AuthorizationHeader _authenticationHeader;
-		private X509CertificateCollection _clientCertificates;
-		private Action<IApiCallDetails> _completedRequestHandler = DefaultCompletedRequestHandler;
-		private int _transportClientLimit;
-		private TimeSpan? _deadTimeout;
-		private bool _disableAutomaticProxyDetection;
-		private bool _disableDirectStreaming;
-		private bool _disablePings;
-		private bool _enableHttpCompression;
-		private bool _enableHttpPipelining = true;
-		private TimeSpan? _keepAliveInterval;
-		private TimeSpan? _keepAliveTime;
-		private TimeSpan? _maxDeadTimeout;
-		private int? _maxRetries;
-		private TimeSpan? _maxRetryTimeout;
-		private Func<Node, bool> _nodePredicate;
-		private Action<RequestData> _onRequestDataCreated = DefaultRequestDataCreated;
-		private TimeSpan? _pingTimeout;
-		private string _proxyAddress;
-		private string _proxyPassword;
-		private string _proxyUsername;
-		private TimeSpan _requestTimeout;
-		private TimeSpan _dnsRefreshTimeout;
-		private Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> _serverCertificateValidationCallback;
-		private IReadOnlyCollection<int> _skipDeserializationForStatusCodes = new ReadOnlyCollection<int>(new int[] { });
-		private TimeSpan? _sniffLifeSpan;
-		private bool _sniffOnConnectionFault;
-		private bool _sniffOnStartup;
-		private bool _throwExceptions;
-		private bool _transferEncodingChunked;
-		private IMemoryStreamFactory _memoryStreamFactory;
-		private bool _enableTcpStats;
-		private bool _enableThreadPoolStats;
-		private UserAgent _userAgent;
-		private string _certificateFingerprint;
-		private bool _disableMetaHeader;
-		private readonly MetaHeaderProvider _metaHeaderProvider;
-
-		private readonly Func<HttpMethod, int, bool> _statusCodeToResponseSuccess;
-
-		/// <summary>
-		/// <inheritdoc cref="TransportConfiguration"/>
-		/// </summary>
-		/// <param name="nodePool"><inheritdoc cref="NodePool" path="/summary"/></param>
-		/// <param name="transportClient"><inheritdoc cref="ITransportClient" path="/summary"/></param>
-		/// <param name="requestResponseSerializer"><inheritdoc cref="Serializer" path="/summary"/></param>
-		/// <param name="productRegistration"><inheritdoc cref="IProductRegistration" path="/summary"/></param>
-		protected TransportConfigurationBase(NodePool nodePool, ITransportClient transportClient, Serializer requestResponseSerializer, IProductRegistration productRegistration)
+		_nodePool = nodePool;
+		_transportClient = transportClient ?? new HttpTransportClient();
+		_productRegistration = productRegistration ?? DefaultProductRegistration.Default;
+		var serializer = requestResponseSerializer ?? new LowLevelRequestResponseSerializer();
+		UseThisRequestResponseSerializer = new DiagnosticsSerializerProxy(serializer);
+
+		_transportClientLimit = TransportConfiguration.DefaultConnectionLimit;
+		_requestTimeout = TransportConfiguration.DefaultTimeout;
+		_dnsRefreshTimeout = TransportConfiguration.DefaultDnsRefreshTimeout;
+		_memoryStreamFactory = TransportConfiguration.DefaultMemoryStreamFactory;
+		_sniffOnConnectionFault = true;
+		_sniffOnStartup = true;
+		_sniffLifeSpan = TimeSpan.FromHours(1);
+
+		_metaHeaderProvider = productRegistration?.MetaHeaderProvider;
+
+		_urlFormatter = new UrlFormatter(this);
+		_statusCodeToResponseSuccess = (m, i) => _productRegistration.HttpStatusCodeClassifier(m, i);
+		_userAgent = Elastic.Transport.UserAgent.Create(_productRegistration.Name, _productRegistration.GetType());
+
+		if (nodePool is CloudNodePool cloudPool)
 		{
-			_nodePool = nodePool;
-			_transportClient = transportClient ?? new HttpTransportClient();
-			_productRegistration = productRegistration ?? ProductRegistration.Default;
-			var serializer = requestResponseSerializer ?? new LowLevelRequestResponseSerializer();
-			UseThisRequestResponseSerializer = new DiagnosticsSerializerProxy(serializer);
-
-			_transportClientLimit = TransportConfiguration.DefaultConnectionLimit;
-			_requestTimeout = TransportConfiguration.DefaultTimeout;
-			_dnsRefreshTimeout = TransportConfiguration.DefaultDnsRefreshTimeout;
-			_memoryStreamFactory = TransportConfiguration.DefaultMemoryStreamFactory;
-			_sniffOnConnectionFault = true;
-			_sniffOnStartup = true;
-			_sniffLifeSpan = TimeSpan.FromHours(1);
-
-			_metaHeaderProvider = productRegistration?.MetaHeaderProvider;
-
-			_urlFormatter = new UrlFormatter(this);
-			_statusCodeToResponseSuccess = (m, i) => _productRegistration.HttpStatusCodeClassifier(m, i);
-			_userAgent = Elastic.Transport.UserAgent.Create(_productRegistration.Name, _productRegistration.GetType());
-
-			if (nodePool is CloudNodePool cloudPool)
-			{
-				_authenticationHeader = cloudPool.AuthenticationHeader;
-				_enableHttpCompression = true;
-			}
-
-			_headersToParse = new HeadersList(_productRegistration.ResponseHeadersToParse);
+			_authenticationHeader = cloudPool.AuthenticationHeader;
+			_enableHttpCompression = true;
 		}
 
-		/// <summary>
-		/// Allows more specialized implementations of <see cref="TransportConfigurationBase{T}"/> to use their own
-		/// request response serializer defaults
-		/// </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		// ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
-		protected Serializer UseThisRequestResponseSerializer { get; set; }
-
-		AuthorizationHeader ITransportConfiguration.Authentication => _authenticationHeader;
-		SemaphoreSlim ITransportConfiguration.BootstrapLock => _semaphore;
-		X509CertificateCollection ITransportConfiguration.ClientCertificates => _clientCertificates;
-		ITransportClient ITransportConfiguration.Connection => _transportClient;
-		IProductRegistration ITransportConfiguration.ProductRegistration => _productRegistration;
-		int ITransportConfiguration.ConnectionLimit => _transportClientLimit;
-		NodePool ITransportConfiguration.NodePool => _nodePool;
-		TimeSpan? ITransportConfiguration.DeadTimeout => _deadTimeout;
-		bool ITransportConfiguration.DisableAutomaticProxyDetection => _disableAutomaticProxyDetection;
-		bool ITransportConfiguration.DisableDirectStreaming => _disableDirectStreaming;
-		bool ITransportConfiguration.DisablePings => _disablePings;
-		bool ITransportConfiguration.EnableHttpCompression => _enableHttpCompression;
-		NameValueCollection ITransportConfiguration.Headers => _headers;
-		bool ITransportConfiguration.HttpPipeliningEnabled => _enableHttpPipelining;
-		TimeSpan? ITransportConfiguration.KeepAliveInterval => _keepAliveInterval;
-		TimeSpan? ITransportConfiguration.KeepAliveTime => _keepAliveTime;
-		TimeSpan? ITransportConfiguration.MaxDeadTimeout => _maxDeadTimeout;
-		int? ITransportConfiguration.MaxRetries => _maxRetries;
-		TimeSpan? ITransportConfiguration.MaxRetryTimeout => _maxRetryTimeout;
-		IMemoryStreamFactory ITransportConfiguration.MemoryStreamFactory => _memoryStreamFactory;
-
-		Func<Node, bool> ITransportConfiguration.NodePredicate => _nodePredicate;
-		Action<IApiCallDetails> ITransportConfiguration.OnRequestCompleted => _completedRequestHandler;
-		Action<RequestData> ITransportConfiguration.OnRequestDataCreated => _onRequestDataCreated;
-		TimeSpan? ITransportConfiguration.PingTimeout => _pingTimeout;
-		string ITransportConfiguration.ProxyAddress => _proxyAddress;
-		string ITransportConfiguration.ProxyPassword => _proxyPassword;
-		string ITransportConfiguration.ProxyUsername => _proxyUsername;
-		NameValueCollection ITransportConfiguration.QueryStringParameters => _queryString;
-		Serializer ITransportConfiguration.RequestResponseSerializer => UseThisRequestResponseSerializer;
-		TimeSpan ITransportConfiguration.RequestTimeout => _requestTimeout;
-		TimeSpan ITransportConfiguration.DnsRefreshTimeout => _dnsRefreshTimeout;
-		string ITransportConfiguration.CertificateFingerprint => _certificateFingerprint;
-
-		Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> ITransportConfiguration.ServerCertificateValidationCallback =>
-			_serverCertificateValidationCallback;
-
-		IReadOnlyCollection<int> ITransportConfiguration.SkipDeserializationForStatusCodes => _skipDeserializationForStatusCodes;
-		TimeSpan? ITransportConfiguration.SniffInformationLifeSpan => _sniffLifeSpan;
-		bool ITransportConfiguration.SniffsOnConnectionFault => _sniffOnConnectionFault;
-		bool ITransportConfiguration.SniffsOnStartup => _sniffOnStartup;
-		bool ITransportConfiguration.ThrowExceptions => _throwExceptions;
-		UrlFormatter ITransportConfiguration.UrlFormatter => _urlFormatter;
-		UserAgent ITransportConfiguration.UserAgent => _userAgent;
-		Func<HttpMethod, int, bool> ITransportConfiguration.StatusCodeToResponseSuccess => _statusCodeToResponseSuccess;
-		bool ITransportConfiguration.TransferEncodingChunked => _transferEncodingChunked;
-		bool ITransportConfiguration.EnableTcpStats => _enableTcpStats;
-		bool ITransportConfiguration.EnableThreadPoolStats => _enableThreadPoolStats;
-
-		void IDisposable.Dispose() => DisposeManagedResources();
-
-		private static void DefaultCompletedRequestHandler(IApiCallDetails response) { }
-
-		private static void DefaultRequestDataCreated(RequestData response) { }
-
-		/// <summary> Assign a private value and return the current <typeparamref name="T"/> </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		protected T Assign<TValue>(TValue value, Action<T, TValue> assigner) => Fluent.Assign((T)this, value, assigner);
-
-		/// <summary>
-		/// Sets the keep-alive option on a TCP connection.
-		/// <para>For Desktop CLR, sets ServicePointManager.SetTcpKeepAlive</para>
-		/// </summary>
-		/// <param name="keepAliveTime"><inheritdoc cref="ITransportConfiguration.KeepAliveTime" path="/summary"/></param>
-		/// <param name="keepAliveInterval"><inheritdoc cref="ITransportConfiguration.KeepAliveInterval" path="/summary"/></param>
-		public T EnableTcpKeepAlive(TimeSpan keepAliveTime, TimeSpan keepAliveInterval) =>
-			Assign(keepAliveTime, (a, v) => a._keepAliveTime = v)
-			.Assign(keepAliveInterval, (a, v) => a._keepAliveInterval = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.MaxRetries"/>
-		public T MaximumRetries(int maxRetries) => Assign(maxRetries, (a, v) => a._maxRetries = v);
-
-		/// <summary>
-		/// <inheritdoc cref="ITransportConfiguration.ConnectionLimit" path="/summary"/>
-		/// </summary>
-		/// <param name="connectionLimit">The connection limit, a value lower then 0 will cause the connection limit not to be set at all</param>
-		public T ConnectionLimit(int connectionLimit) => Assign(connectionLimit, (a, v) => a._transportClientLimit = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.SniffsOnConnectionFault"/>
-		public T SniffOnConnectionFault(bool sniffsOnConnectionFault = true) =>
-			Assign(sniffsOnConnectionFault, (a, v) => a._sniffOnConnectionFault = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.SniffsOnStartup"/>
-		public T SniffOnStartup(bool sniffsOnStartup = true) => Assign(sniffsOnStartup, (a, v) => a._sniffOnStartup = v);
-
-		/// <summary>
-		/// <inheritdoc cref="ITransportConfiguration.SniffInformationLifeSpan" path="/summary"/>
-		/// </summary>
-		/// <param name="sniffLifeSpan">The duration a clusterstate is considered fresh, set to null to disable periodic sniffing</param>
-		public T SniffLifeSpan(TimeSpan? sniffLifeSpan) => Assign(sniffLifeSpan, (a, v) => a._sniffLifeSpan = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.EnableHttpCompression"/>
-		public T EnableHttpCompression(bool enabled = true) => Assign(enabled, (a, v) => a._enableHttpCompression = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.DisableAutomaticProxyDetection"/>
-		public T DisableAutomaticProxyDetection(bool disable = true) => Assign(disable, (a, v) => a._disableAutomaticProxyDetection = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.ThrowExceptions"/>
-		public T ThrowExceptions(bool alwaysThrow = true) => Assign(alwaysThrow, (a, v) => a._throwExceptions = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.DisablePings"/>
-		public T DisablePing(bool disable = true) => Assign(disable, (a, v) => a._disablePings = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.QueryStringParameters"/>
-		// ReSharper disable once MemberCanBePrivate.Global
-		public T GlobalQueryStringParameters(NameValueCollection queryStringParameters) => Assign(queryStringParameters, (a, v) => a._queryString.Add(v));
-
-		/// <inheritdoc cref="ITransportConfiguration.Headers"/>
-		public T GlobalHeaders(NameValueCollection headers) => Assign(headers, (a, v) => a._headers.Add(v));
-
-		/// <inheritdoc cref="ITransportConfiguration.RequestTimeout"/>
-		public T RequestTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._requestTimeout = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.PingTimeout"/>
-		public T PingTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._pingTimeout = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.DeadTimeout"/>
-		public T DeadTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._deadTimeout = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.MaxDeadTimeout"/>
-		public T MaxDeadTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._maxDeadTimeout = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.MaxRetryTimeout"/>
-		public T MaxRetryTimeout(TimeSpan maxRetryTimeout) => Assign(maxRetryTimeout, (a, v) => a._maxRetryTimeout = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.DnsRefreshTimeout"/>
-		public T DnsRefreshTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._dnsRefreshTimeout = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.CertificateFingerprint"/>
-		public T CertificateFingerprint(string fingerprint) => Assign(fingerprint, (a, v) => a._certificateFingerprint = v);
-
-		/// <summary>
-		/// If your connection has to go through proxy, use this method to specify the proxy url
-		/// </summary>
-		public T Proxy(Uri proxyAddress, string username, string password) =>
-			Assign(proxyAddress.ToString(), (a, v) => a._proxyAddress = v)
-				.Assign(username, (a, v) => a._proxyUsername = v)
-				.Assign(password, (a, v) => a._proxyPassword = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.DisableDirectStreaming"/>
-		// ReSharper disable once MemberCanBePrivate.Global
-		public T DisableDirectStreaming(bool b = true) => Assign(b, (a, v) => a._disableDirectStreaming = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.OnRequestCompleted"/>
-		public T OnRequestCompleted(Action<IApiCallDetails> handler) =>
-			Assign(handler, (a, v) => a._completedRequestHandler += v ?? DefaultCompletedRequestHandler);
+		_headersToParse = new HeadersList(_productRegistration.ResponseHeadersToParse);
+	}
+
+	/// <summary>
+	/// Allows more specialized implementations of <see cref="TransportConfigurationBase{T}"/> to use their own
+	/// request response serializer defaults
+	/// </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	// ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
+	protected Serializer UseThisRequestResponseSerializer { get; set; }
+
+	AuthorizationHeader ITransportConfiguration.Authentication => _authenticationHeader;
+	SemaphoreSlim ITransportConfiguration.BootstrapLock => _semaphore;
+	X509CertificateCollection ITransportConfiguration.ClientCertificates => _clientCertificates;
+	TransportClient ITransportConfiguration.Connection => _transportClient;
+	ProductRegistration ITransportConfiguration.ProductRegistration => _productRegistration;
+	int ITransportConfiguration.ConnectionLimit => _transportClientLimit;
+	NodePool ITransportConfiguration.NodePool => _nodePool;
+	TimeSpan? ITransportConfiguration.DeadTimeout => _deadTimeout;
+	bool ITransportConfiguration.DisableAutomaticProxyDetection => _disableAutomaticProxyDetection;
+	bool ITransportConfiguration.DisableDirectStreaming => _disableDirectStreaming;
+	bool ITransportConfiguration.DisablePings => _disablePings;
+	bool ITransportConfiguration.EnableHttpCompression => _enableHttpCompression;
+	NameValueCollection ITransportConfiguration.Headers => _headers;
+	bool ITransportConfiguration.HttpPipeliningEnabled => _enableHttpPipelining;
+	TimeSpan? ITransportConfiguration.KeepAliveInterval => _keepAliveInterval;
+	TimeSpan? ITransportConfiguration.KeepAliveTime => _keepAliveTime;
+	TimeSpan? ITransportConfiguration.MaxDeadTimeout => _maxDeadTimeout;
+	int? ITransportConfiguration.MaxRetries => _maxRetries;
+	TimeSpan? ITransportConfiguration.MaxRetryTimeout => _maxRetryTimeout;
+	MemoryStreamFactory ITransportConfiguration.MemoryStreamFactory => _memoryStreamFactory;
+
+	Func<Node, bool> ITransportConfiguration.NodePredicate => _nodePredicate;
+	Action<ApiCallDetails> ITransportConfiguration.OnRequestCompleted => _completedRequestHandler;
+	Action<RequestData> ITransportConfiguration.OnRequestDataCreated => _onRequestDataCreated;
+	TimeSpan? ITransportConfiguration.PingTimeout => _pingTimeout;
+	string ITransportConfiguration.ProxyAddress => _proxyAddress;
+	string ITransportConfiguration.ProxyPassword => _proxyPassword;
+	string ITransportConfiguration.ProxyUsername => _proxyUsername;
+	NameValueCollection ITransportConfiguration.QueryStringParameters => _queryString;
+	Serializer ITransportConfiguration.RequestResponseSerializer => UseThisRequestResponseSerializer;
+	TimeSpan ITransportConfiguration.RequestTimeout => _requestTimeout;
+	TimeSpan ITransportConfiguration.DnsRefreshTimeout => _dnsRefreshTimeout;
+	string ITransportConfiguration.CertificateFingerprint => _certificateFingerprint;
+
+	Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> ITransportConfiguration.ServerCertificateValidationCallback =>
+		_serverCertificateValidationCallback;
+
+	IReadOnlyCollection<int> ITransportConfiguration.SkipDeserializationForStatusCodes => _skipDeserializationForStatusCodes;
+	TimeSpan? ITransportConfiguration.SniffInformationLifeSpan => _sniffLifeSpan;
+	bool ITransportConfiguration.SniffsOnConnectionFault => _sniffOnConnectionFault;
+	bool ITransportConfiguration.SniffsOnStartup => _sniffOnStartup;
+	bool ITransportConfiguration.ThrowExceptions => _throwExceptions;
+	UrlFormatter ITransportConfiguration.UrlFormatter => _urlFormatter;
+	UserAgent ITransportConfiguration.UserAgent => _userAgent;
+	Func<HttpMethod, int, bool> ITransportConfiguration.StatusCodeToResponseSuccess => _statusCodeToResponseSuccess;
+	bool ITransportConfiguration.TransferEncodingChunked => _transferEncodingChunked;
+	bool ITransportConfiguration.EnableTcpStats => _enableTcpStats;
+	bool ITransportConfiguration.EnableThreadPoolStats => _enableThreadPoolStats;
+
+	void IDisposable.Dispose() => DisposeManagedResources();
+
+	private static void DefaultCompletedRequestHandler(ApiCallDetails response) { }
+
+	private static void DefaultRequestDataCreated(RequestData response) { }
+
+	/// <summary> Assign a private value and return the current <typeparamref name="T"/> </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	protected T Assign<TValue>(TValue value, Action<T, TValue> assigner) => Fluent.Assign((T)this, value, assigner);
+
+	/// <summary>
+	/// Sets the keep-alive option on a TCP connection.
+	/// <para>For Desktop CLR, sets ServicePointManager.SetTcpKeepAlive</para>
+	/// </summary>
+	/// <param name="keepAliveTime"><inheritdoc cref="ITransportConfiguration.KeepAliveTime" path="/summary"/></param>
+	/// <param name="keepAliveInterval"><inheritdoc cref="ITransportConfiguration.KeepAliveInterval" path="/summary"/></param>
+	public T EnableTcpKeepAlive(TimeSpan keepAliveTime, TimeSpan keepAliveInterval) =>
+		Assign(keepAliveTime, (a, v) => a._keepAliveTime = v)
+		.Assign(keepAliveInterval, (a, v) => a._keepAliveInterval = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.MaxRetries"/>
+	public T MaximumRetries(int maxRetries) => Assign(maxRetries, (a, v) => a._maxRetries = v);
+
+	/// <summary>
+	/// <inheritdoc cref="ITransportConfiguration.ConnectionLimit" path="/summary"/>
+	/// </summary>
+	/// <param name="connectionLimit">The connection limit, a value lower then 0 will cause the connection limit not to be set at all</param>
+	public T ConnectionLimit(int connectionLimit) => Assign(connectionLimit, (a, v) => a._transportClientLimit = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.OnRequestDataCreated"/>
-		public T OnRequestDataCreated(Action<RequestData> handler) =>
-			Assign(handler, (a, v) => a._onRequestDataCreated += v ?? DefaultRequestDataCreated);
+	/// <inheritdoc cref="ITransportConfiguration.SniffsOnConnectionFault"/>
+	public T SniffOnConnectionFault(bool sniffsOnConnectionFault = true) =>
+		Assign(sniffsOnConnectionFault, (a, v) => a._sniffOnConnectionFault = v);
 
-		/// <inheritdoc cref="AuthorizationHeader"/>
-		public T Authentication(AuthorizationHeader header) => Assign(header, (a, v) => a._authenticationHeader = v);
-
-		/// <inheritdoc cref="ITransportConfiguration.HttpPipeliningEnabled"/>
-		public T EnableHttpPipelining(bool enabled = true) => Assign(enabled, (a, v) => a._enableHttpPipelining = v);
-
-		/// <summary>
-		/// <inheritdoc cref="ITransportConfiguration.NodePredicate"/>
-		/// </summary>
-		/// <param name="predicate">Return true if you want the node to be used for API calls</param>
-		public T NodePredicate(Func<Node, bool> predicate) => Assign(predicate, (a, v) => a._nodePredicate = v);
-
-		/// <summary>
-		/// Turns on settings that aid in debugging like DisableDirectStreaming() and PrettyJson()
-		/// so that the original request and response JSON can be inspected. It also always asks the server for the full stack trace on errors
-		/// </summary>
-		/// <param name="onRequestCompleted">
-		/// An optional callback to be performed when the request completes. This will
-		/// not overwrite the global OnRequestCompleted callback that is set directly on
-		/// ConnectionSettings. If no callback is passed, DebugInformation from the response
-		/// will be written to the debug output by default.
-		/// </param>
-		// ReSharper disable once VirtualMemberNeverOverridden.Global
-		public virtual T EnableDebugMode(Action<IApiCallDetails> onRequestCompleted = null) =>
-			PrettyJson()
-				.DisableDirectStreaming()
-				.EnableTcpStats()
-				.EnableThreadPoolStats()
-				.Assign(onRequestCompleted, (a, v) =>
-					_completedRequestHandler += v ?? (d => Debug.WriteLine(d.DebugInformation)));
+	/// <inheritdoc cref="ITransportConfiguration.SniffsOnStartup"/>
+	public T SniffOnStartup(bool sniffsOnStartup = true) => Assign(sniffsOnStartup, (a, v) => a._sniffOnStartup = v);
 
-		private bool _prettyJson;
-		bool ITransportConfiguration.PrettyJson => _prettyJson;
+	/// <summary>
+	/// <inheritdoc cref="ITransportConfiguration.SniffInformationLifeSpan" path="/summary"/>
+	/// </summary>
+	/// <param name="sniffLifeSpan">The duration a clusterstate is considered fresh, set to null to disable periodic sniffing</param>
+	public T SniffLifeSpan(TimeSpan? sniffLifeSpan) => Assign(sniffLifeSpan, (a, v) => a._sniffLifeSpan = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.PrettyJson"/>
-		// ReSharper disable once VirtualMemberNeverOverridden.Global
-		// ReSharper disable once MemberCanBeProtected.Global
-		public virtual T PrettyJson(bool b = true) => Assign(b, (a, v) => a._prettyJson = v);
+	/// <inheritdoc cref="ITransportConfiguration.EnableHttpCompression"/>
+	public T EnableHttpCompression(bool enabled = true) => Assign(enabled, (a, v) => a._enableHttpCompression = v);
 
-		private bool? _parseAllHeaders;
-		bool? ITransportConfiguration.ParseAllHeaders => _parseAllHeaders;
+	/// <inheritdoc cref="ITransportConfiguration.DisableAutomaticProxyDetection"/>
+	public T DisableAutomaticProxyDetection(bool disable = true) => Assign(disable, (a, v) => a._disableAutomaticProxyDetection = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.ParseAllHeaders"/>
-		public virtual T ParseAllHeaders(bool b = true) => Assign(b, (a, v) => a._parseAllHeaders = v);
+	/// <inheritdoc cref="ITransportConfiguration.ThrowExceptions"/>
+	public T ThrowExceptions(bool alwaysThrow = true) => Assign(alwaysThrow, (a, v) => a._throwExceptions = v);
 
-		private HeadersList _headersToParse;
-		HeadersList ITransportConfiguration.ResponseHeadersToParse => _headersToParse;
+	/// <inheritdoc cref="ITransportConfiguration.DisablePings"/>
+	public T DisablePing(bool disable = true) => Assign(disable, (a, v) => a._disablePings = v);
 
-		MetaHeaderProvider ITransportConfiguration.MetaHeaderProvider => _metaHeaderProvider;
-
-		bool ITransportConfiguration.DisableMetaHeader => _disableMetaHeader;
+	/// <inheritdoc cref="ITransportConfiguration.QueryStringParameters"/>
+	// ReSharper disable once MemberCanBePrivate.Global
+	public T GlobalQueryStringParameters(NameValueCollection queryStringParameters) => Assign(queryStringParameters, (a, v) => a._queryString.Add(v));
 
-		/// <inheritdoc cref="ITransportConfiguration.ResponseHeadersToParse"/>
-		public virtual T ResponseHeadersToParse(HeadersList headersToParse)
-		{
-			_headersToParse = new HeadersList(_headersToParse, headersToParse);
-			return (T)this;
-		}
+	/// <inheritdoc cref="ITransportConfiguration.Headers"/>
+	public T GlobalHeaders(NameValueCollection headers) => Assign(headers, (a, v) => a._headers.Add(v));
 
-		/// <inheritdoc cref="ITransportConfiguration.ServerCertificateValidationCallback"/>
-		public T ServerCertificateValidationCallback(Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> callback) =>
-			Assign(callback, (a, v) => a._serverCertificateValidationCallback = v);
+	/// <inheritdoc cref="ITransportConfiguration.RequestTimeout"/>
+	public T RequestTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._requestTimeout = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.ClientCertificates"/>
-		public T ClientCertificates(X509CertificateCollection certificates) =>
-			Assign(certificates, (a, v) => a._clientCertificates = v);
+	/// <inheritdoc cref="ITransportConfiguration.PingTimeout"/>
+	public T PingTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._pingTimeout = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.ClientCertificates"/>
-		public T ClientCertificate(X509Certificate certificate) =>
-			Assign(new X509Certificate2Collection { certificate }, (a, v) => a._clientCertificates = v);
+	/// <inheritdoc cref="ITransportConfiguration.DeadTimeout"/>
+	public T DeadTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._deadTimeout = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.ClientCertificates"/>
-		public T ClientCertificate(string certificatePath) =>
-			Assign(new X509Certificate2Collection { new X509Certificate(certificatePath) }, (a, v) => a._clientCertificates = v);
+	/// <inheritdoc cref="ITransportConfiguration.MaxDeadTimeout"/>
+	public T MaxDeadTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._maxDeadTimeout = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.SkipDeserializationForStatusCodes"/>
-		public T SkipDeserializationForStatusCodes(params int[] statusCodes) =>
-			Assign(new ReadOnlyCollection<int>(statusCodes), (a, v) => a._skipDeserializationForStatusCodes = v);
+	/// <inheritdoc cref="ITransportConfiguration.MaxRetryTimeout"/>
+	public T MaxRetryTimeout(TimeSpan maxRetryTimeout) => Assign(maxRetryTimeout, (a, v) => a._maxRetryTimeout = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.UserAgent"/>
-		public T UserAgent(UserAgent userAgent) => Assign(userAgent, (a, v) => a._userAgent = v);
+	/// <inheritdoc cref="ITransportConfiguration.DnsRefreshTimeout"/>
+	public T DnsRefreshTimeout(TimeSpan timeout) => Assign(timeout, (a, v) => a._dnsRefreshTimeout = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.TransferEncodingChunked"/>
-		public T TransferEncodingChunked(bool transferEncodingChunked = true) => Assign(transferEncodingChunked, (a, v) => a._transferEncodingChunked = v);
+	/// <inheritdoc cref="ITransportConfiguration.CertificateFingerprint"/>
+	public T CertificateFingerprint(string fingerprint) => Assign(fingerprint, (a, v) => a._certificateFingerprint = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.MemoryStreamFactory"/>
-		public T MemoryStreamFactory(IMemoryStreamFactory memoryStreamFactory) => Assign(memoryStreamFactory, (a, v) => a._memoryStreamFactory = v);
+	/// <summary>
+	/// If your connection has to go through proxy, use this method to specify the proxy url
+	/// </summary>
+	public T Proxy(Uri proxyAddress, string username, string password) =>
+		Assign(proxyAddress.ToString(), (a, v) => a._proxyAddress = v)
+			.Assign(username, (a, v) => a._proxyUsername = v)
+			.Assign(password, (a, v) => a._proxyPassword = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.EnableTcpStats"/>>
-		public T EnableTcpStats(bool enableTcpStats = true) => Assign(enableTcpStats, (a, v) => a._enableTcpStats = v);
+	/// <inheritdoc cref="ITransportConfiguration.DisableDirectStreaming"/>
+	// ReSharper disable once MemberCanBePrivate.Global
+	public T DisableDirectStreaming(bool b = true) => Assign(b, (a, v) => a._disableDirectStreaming = v);
 
-		/// <inheritdoc cref="ITransportConfiguration.EnableThreadPoolStats"/>>
-		public T EnableThreadPoolStats(bool enableThreadPoolStats = true) => Assign(enableThreadPoolStats, (a, v) => a._enableThreadPoolStats = v);
+	/// <inheritdoc cref="ITransportConfiguration.OnRequestCompleted"/>
+	public T OnRequestCompleted(Action<ApiCallDetails> handler) =>
+		Assign(handler, (a, v) => a._completedRequestHandler += v ?? DefaultCompletedRequestHandler);
 
-		/// <inheritdoc cref="ITransportConfiguration.DisableMetaHeader"/>>
-		public T DisableMetaHeader(bool disable = true) => Assign(disable, (a, v) => a._disableMetaHeader = v);
+	/// <inheritdoc cref="ITransportConfiguration.OnRequestDataCreated"/>
+	public T OnRequestDataCreated(Action<RequestData> handler) =>
+		Assign(handler, (a, v) => a._onRequestDataCreated += v ?? DefaultRequestDataCreated);
 
-		// ReSharper disable once VirtualMemberNeverOverridden.Global
-		/// <summary> Allows subclasses to hook into the parents dispose </summary>
-		protected virtual void DisposeManagedResources()
-		{
-			_nodePool?.Dispose();
-			_transportClient?.Dispose();
-			_semaphore?.Dispose();
-		}
+	/// <inheritdoc cref="AuthorizationHeader"/>
+	public T Authentication(AuthorizationHeader header) => Assign(header, (a, v) => a._authenticationHeader = v);
 
-		/// <summary> Allows subclasses to add/remove default global query string parameters </summary>
-		protected T UpdateGlobalQueryString(string key, string value, bool enabled)
-		{
-			if (!enabled && _queryString[key] != null) _queryString.Remove(key);
-			else if (enabled && _queryString[key] == null)
-				return GlobalQueryStringParameters(new NameValueCollection { { key, "true" } });
-			return (T)this;
-		}
+	/// <inheritdoc cref="ITransportConfiguration.HttpPipeliningEnabled"/>
+	public T EnableHttpPipelining(bool enabled = true) => Assign(enabled, (a, v) => a._enableHttpPipelining = v);
 
+	/// <summary>
+	/// <inheritdoc cref="ITransportConfiguration.NodePredicate"/>
+	/// </summary>
+	/// <param name="predicate">Return true if you want the node to be used for API calls</param>
+	public T NodePredicate(Func<Node, bool> predicate) => Assign(predicate, (a, v) => a._nodePredicate = v);
+
+	/// <summary>
+	/// Turns on settings that aid in debugging like DisableDirectStreaming() and PrettyJson()
+	/// so that the original request and response JSON can be inspected. It also always asks the server for the full stack trace on errors
+	/// </summary>
+	/// <param name="onRequestCompleted">
+	/// An optional callback to be performed when the request completes. This will
+	/// not overwrite the global OnRequestCompleted callback that is set directly on
+	/// ConnectionSettings. If no callback is passed, DebugInformation from the response
+	/// will be written to the debug output by default.
+	/// </param>
+	// ReSharper disable once VirtualMemberNeverOverridden.Global
+	public virtual T EnableDebugMode(Action<ApiCallDetails> onRequestCompleted = null) =>
+		PrettyJson()
+			.DisableDirectStreaming()
+			.EnableTcpStats()
+			.EnableThreadPoolStats()
+			.Assign(onRequestCompleted, (a, v) =>
+				_completedRequestHandler += v ?? (d => Debug.WriteLine(d.DebugInformation)));
+
+	private bool _prettyJson;
+	bool ITransportConfiguration.PrettyJson => _prettyJson;
+
+	/// <inheritdoc cref="ITransportConfiguration.PrettyJson"/>
+	// ReSharper disable once VirtualMemberNeverOverridden.Global
+	// ReSharper disable once MemberCanBeProtected.Global
+	public virtual T PrettyJson(bool b = true) => Assign(b, (a, v) => a._prettyJson = v);
+
+	private bool? _parseAllHeaders;
+	bool? ITransportConfiguration.ParseAllHeaders => _parseAllHeaders;
+
+	/// <inheritdoc cref="ITransportConfiguration.ParseAllHeaders"/>
+	public virtual T ParseAllHeaders(bool b = true) => Assign(b, (a, v) => a._parseAllHeaders = v);
+
+	private HeadersList _headersToParse;
+	HeadersList ITransportConfiguration.ResponseHeadersToParse => _headersToParse;
+
+	MetaHeaderProvider ITransportConfiguration.MetaHeaderProvider => _metaHeaderProvider;
+
+	bool ITransportConfiguration.DisableMetaHeader => _disableMetaHeader;
+
+	/// <inheritdoc cref="ITransportConfiguration.ResponseHeadersToParse"/>
+	public virtual T ResponseHeadersToParse(HeadersList headersToParse)
+	{
+		_headersToParse = new HeadersList(_headersToParse, headersToParse);
+		return (T)this;
+	}
+
+	/// <inheritdoc cref="ITransportConfiguration.ServerCertificateValidationCallback"/>
+	public T ServerCertificateValidationCallback(Func<object, X509Certificate, X509Chain, SslPolicyErrors, bool> callback) =>
+		Assign(callback, (a, v) => a._serverCertificateValidationCallback = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.ClientCertificates"/>
+	public T ClientCertificates(X509CertificateCollection certificates) =>
+		Assign(certificates, (a, v) => a._clientCertificates = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.ClientCertificates"/>
+	public T ClientCertificate(X509Certificate certificate) =>
+		Assign(new X509Certificate2Collection { certificate }, (a, v) => a._clientCertificates = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.ClientCertificates"/>
+	public T ClientCertificate(string certificatePath) =>
+		Assign(new X509Certificate2Collection { new X509Certificate(certificatePath) }, (a, v) => a._clientCertificates = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.SkipDeserializationForStatusCodes"/>
+	public T SkipDeserializationForStatusCodes(params int[] statusCodes) =>
+		Assign(new ReadOnlyCollection<int>(statusCodes), (a, v) => a._skipDeserializationForStatusCodes = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.UserAgent"/>
+	public T UserAgent(UserAgent userAgent) => Assign(userAgent, (a, v) => a._userAgent = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.TransferEncodingChunked"/>
+	public T TransferEncodingChunked(bool transferEncodingChunked = true) => Assign(transferEncodingChunked, (a, v) => a._transferEncodingChunked = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.MemoryStreamFactory"/>
+	public T MemoryStreamFactory(MemoryStreamFactory memoryStreamFactory) => Assign(memoryStreamFactory, (a, v) => a._memoryStreamFactory = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.EnableTcpStats"/>>
+	public T EnableTcpStats(bool enableTcpStats = true) => Assign(enableTcpStats, (a, v) => a._enableTcpStats = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.EnableThreadPoolStats"/>>
+	public T EnableThreadPoolStats(bool enableThreadPoolStats = true) => Assign(enableThreadPoolStats, (a, v) => a._enableThreadPoolStats = v);
+
+	/// <inheritdoc cref="ITransportConfiguration.DisableMetaHeader"/>>
+	public T DisableMetaHeader(bool disable = true) => Assign(disable, (a, v) => a._disableMetaHeader = v);
+
+	// ReSharper disable once VirtualMemberNeverOverridden.Global
+	/// <summary> Allows subclasses to hook into the parents dispose </summary>
+	protected virtual void DisposeManagedResources()
+	{
+		_nodePool?.Dispose();
+		_transportClient?.Dispose();
+		_semaphore?.Dispose();
+	}
+
+	/// <summary> Allows subclasses to add/remove default global query string parameters </summary>
+	protected T UpdateGlobalQueryString(string key, string value, bool enabled)
+	{
+		if (!enabled && _queryString[key] != null) _queryString.Remove(key);
+		else if (enabled && _queryString[key] == null)
+			return GlobalQueryStringParameters(new NameValueCollection { { key, "true" } });
+		return (T)this;
 	}
 }
diff --git a/src/Elastic.Transport/Configuration/UserAgent.cs b/src/Elastic.Transport/Configuration/UserAgent.cs
index 3b104bd..55c931a 100644
--- a/src/Elastic.Transport/Configuration/UserAgent.cs
+++ b/src/Elastic.Transport/Configuration/UserAgent.cs
@@ -7,46 +7,45 @@
 using System.Runtime.InteropServices;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Represents the user agent string. Two constructors exists, one to aid with constructing elastic clients standard compliant
+/// user agents and one free form to allow any custom string to be set.
+/// </summary>
+public sealed class UserAgent
 {
-	/// <summary>
-	/// Represents the user agent string. Two constructors exists, one to aid with constructing elastic clients standard compliant
-	/// user agents and one free form to allow any custom string to be set.
-	/// </summary>
-	public sealed class UserAgent
-	{
-		private readonly string _toString;
+	private readonly string _toString;
 
-		private UserAgent(string reposName, Type typeVersionLookup, string[] metadata = null)
-		{
-			var version = typeVersionLookup.Assembly
-				.GetCustomAttribute<AssemblyInformationalVersionAttribute>()
-				.InformationalVersion;
+	private UserAgent(string reposName, Type typeVersionLookup, string[] metadata = null)
+	{
+		var version = typeVersionLookup.Assembly
+			.GetCustomAttribute<AssemblyInformationalVersionAttribute>()
+			.InformationalVersion;
 
-			var meta = string.Join("; ", metadata ?? Array.Empty<string>());
-			var assemblyName = typeVersionLookup.Assembly.GetName().Name;
+		var meta = string.Join("; ", metadata ?? Array.Empty<string>());
+		var assemblyName = typeVersionLookup.Assembly.GetName().Name;
 
-			_toString = $"{reposName}/{version} ({RuntimeInformation.OSDescription}; {RuntimeInformation.FrameworkDescription}; {assemblyName}{meta.Trim()})";
-		}
+		_toString = $"{reposName}/{version} ({RuntimeInformation.OSDescription}; {RuntimeInformation.FrameworkDescription}; {assemblyName}{meta.Trim()})";
+	}
 
-		private UserAgent(string fullUserAgentString) => _toString = fullUserAgentString;
+	private UserAgent(string fullUserAgentString) => _toString = fullUserAgentString;
 
-		/// <summary> Create a user agent that adhers to the minimum information needed to be elastic standard compliant </summary>
-		/// <param name="reposName">The repos name uniquely identifies the origin of the client</param>
-		/// <param name="typeVersionLookup">
-		/// Use <see cref="Type"/>'s assembly <see cref="AssemblyInformationalVersionAttribute"/>
-		/// to inject version information into the header
-		/// </param>
-		public static UserAgent Create(string reposName, Type typeVersionLookup) => new UserAgent(reposName, typeVersionLookup);
+	/// <summary> Create a user agent that adhers to the minimum information needed to be elastic standard compliant </summary>
+	/// <param name="reposName">The repos name uniquely identifies the origin of the client</param>
+	/// <param name="typeVersionLookup">
+	/// Use <see cref="Type"/>'s assembly <see cref="AssemblyInformationalVersionAttribute"/>
+	/// to inject version information into the header
+	/// </param>
+	public static UserAgent Create(string reposName, Type typeVersionLookup) => new UserAgent(reposName, typeVersionLookup);
 
-		/// <summary> <inheritdoc cref="Create(string,System.Type)"/> </summary>
-		public static UserAgent Create(string reposName, Type typeVersionLookup, string[] metadata) => new UserAgent(reposName, typeVersionLookup, metadata);
+	/// <summary> <inheritdoc cref="Create(string,System.Type)"/> </summary>
+	public static UserAgent Create(string reposName, Type typeVersionLookup, string[] metadata) => new UserAgent(reposName, typeVersionLookup, metadata);
 
-		/// <summary> Create a user string that does not confirm to elastic client standards </summary>
-		public static UserAgent Create(string fullUserAgentString) => new UserAgent(fullUserAgentString);
+	/// <summary> Create a user string that does not confirm to elastic client standards </summary>
+	public static UserAgent Create(string fullUserAgentString) => new UserAgent(fullUserAgentString);
 
-		/// <summary> The precalculated string representation of this <see cref="UserAgent"/> instance </summary>
-		/// <returns></returns>
-		public override string ToString() => _toString;
-	}
+	/// <summary> The precalculated string representation of this <see cref="UserAgent"/> instance </summary>
+	/// <returns></returns>
+	public override string ToString() => _toString;
 }
diff --git a/src/Elastic.Transport/DefaultHttpTransport.cs b/src/Elastic.Transport/DefaultHttpTransport.cs
new file mode 100644
index 0000000..fa4df76
--- /dev/null
+++ b/src/Elastic.Transport/DefaultHttpTransport.cs
@@ -0,0 +1,420 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Elastic.Transport.Extensions;
+using Elastic.Transport.Products;
+
+#if !DOTNETCORE
+using System.Net;
+#endif
+
+namespace Elastic.Transport;
+
+/// <inheritdoc cref="HttpTransport{TConnectionSettings}" />
+public sealed class DefaultHttpTransport : DefaultHttpTransport<TransportConfiguration>
+{
+	/// <summary>
+	///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
+	///     different
+	///     nodes
+	/// </summary>
+	/// <param name="configurationValues">The connection settings to use for this transport</param>
+	public DefaultHttpTransport(TransportConfiguration configurationValues) : base(configurationValues)
+	{
+	}
+
+	/// <summary>
+	///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
+	///     different
+	///     nodes
+	/// </summary>
+	/// <param name="configurationValues">The connection settings to use for this transport</param>
+	/// <param name="dateTimeProvider">The date time proved to use, safe to pass null to use the default</param>
+	/// <param name="memoryStreamFactory">The memory stream provider to use, safe to pass null to use the default</param>
+	public DefaultHttpTransport(TransportConfiguration configurationValues,
+		DateTimeProvider dateTimeProvider = null, MemoryStreamFactory memoryStreamFactory = null
+	)
+		: base(configurationValues, null, dateTimeProvider, memoryStreamFactory)
+	{
+	}
+
+	/// <summary>
+	///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
+	///     different
+	///     nodes
+	/// </summary>
+	/// <param name="configurationValues">The connection settings to use for this transport</param>
+	/// <param name="pipelineProvider">In charge of create a new pipeline, safe to pass null to use the default</param>
+	/// <param name="dateTimeProvider">The date time proved to use, safe to pass null to use the default</param>
+	/// <param name="memoryStreamFactory">The memory stream provider to use, safe to pass null to use the default</param>
+	internal DefaultHttpTransport(TransportConfiguration configurationValues,
+		RequestPipelineFactory<TransportConfiguration> pipelineProvider = null,
+		DateTimeProvider dateTimeProvider = null, MemoryStreamFactory memoryStreamFactory = null
+	)
+		: base(configurationValues, pipelineProvider, dateTimeProvider, memoryStreamFactory)
+	{
+	}
+}
+
+/// <inheritdoc cref="HttpTransport{TConfiguration}" />
+public class DefaultHttpTransport<TConfiguration> : HttpTransport<TConfiguration>
+	where TConfiguration : class, ITransportConfiguration
+{
+	private readonly ProductRegistration _productRegistration;
+
+	/// <summary>
+	///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
+	///     different
+	///     nodes
+	/// </summary>
+	/// <param name="configurationValues">The connection settings to use for this transport</param>
+	public DefaultHttpTransport(TConfiguration configurationValues) : this(configurationValues, null, null, null)
+	{
+	}
+
+	/// <summary>
+	///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
+	///     different
+	///     nodes
+	/// </summary>
+	/// <param name="configurationValues">The connection settings to use for this transport</param>
+	/// <param name="dateTimeProvider">The date time proved to use, safe to pass null to use the default</param>
+	/// <param name="memoryStreamFactory">The memory stream provider to use, safe to pass null to use the default</param>
+	public DefaultHttpTransport(
+		TConfiguration configurationValues,
+		DateTimeProvider dateTimeProvider = null,
+		MemoryStreamFactory memoryStreamFactory = null)
+			: this(configurationValues, null, dateTimeProvider, memoryStreamFactory) { }
+
+	/// <summary>
+	///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
+	///     different
+	///     nodes
+	/// </summary>
+	/// <param name="configurationValues">The connection settings to use for this transport</param>
+	/// <param name="pipelineProvider">In charge of create a new pipeline, safe to pass null to use the default</param>
+	/// <param name="dateTimeProvider">The date time proved to use, safe to pass null to use the default</param>
+	/// <param name="memoryStreamFactory">The memory stream provider to use, safe to pass null to use the default</param>
+	public DefaultHttpTransport(
+		TConfiguration configurationValues,
+		RequestPipelineFactory<TConfiguration> pipelineProvider = null,
+		DateTimeProvider dateTimeProvider = null,
+		MemoryStreamFactory memoryStreamFactory = null
+	)
+	{
+		configurationValues.ThrowIfNull(nameof(configurationValues));
+		configurationValues.NodePool.ThrowIfNull(nameof(configurationValues.NodePool));
+		configurationValues.Connection.ThrowIfNull(nameof(configurationValues.Connection));
+		configurationValues.RequestResponseSerializer.ThrowIfNull(nameof(configurationValues
+			.RequestResponseSerializer));
+
+		_productRegistration = configurationValues.ProductRegistration;
+		Settings = configurationValues;
+		PipelineProvider = pipelineProvider ?? new DefaultRequestPipelineFactory<TConfiguration>();
+		DateTimeProvider = dateTimeProvider ?? Elastic.Transport.DefaultDateTimeProvider.Default;
+		MemoryStreamFactory = memoryStreamFactory ?? configurationValues.MemoryStreamFactory;
+	}
+
+	private DateTimeProvider DateTimeProvider { get; }
+	private MemoryStreamFactory MemoryStreamFactory { get; }
+	private RequestPipelineFactory<TConfiguration> PipelineProvider { get; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public override TConfiguration Settings { get; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <typeparam name="TResponse"></typeparam>
+	/// <param name="method"></param>
+	/// <param name="path"></param>
+	/// <param name="data"></param>
+	/// <param name="requestParameters"></param>
+	/// <returns></returns>
+	public override TResponse Request<TResponse>(HttpMethod method, string path, PostData data = null,
+		RequestParameters requestParameters = null)
+	{
+		using var pipeline =
+			PipelineProvider.Create(Settings, DateTimeProvider, MemoryStreamFactory, requestParameters);
+
+		pipeline.FirstPoolUsage(Settings.BootstrapLock);
+
+		var requestData = new RequestData(method, path, data, Settings, requestParameters, MemoryStreamFactory);
+		Settings.OnRequestDataCreated?.Invoke(requestData);
+		TResponse response = null;
+
+		var seenExceptions = new List<PipelineException>();
+
+		if (pipeline.TryGetSingleNode(out var singleNode))
+		{
+			// No value in marking a single node as dead. We have no other options!
+
+			requestData.Node = singleNode;
+
+			try
+			{
+				response = pipeline.CallProductEndpoint<TResponse>(requestData);
+			}
+			catch (PipelineException pipelineException) when (!pipelineException.Recoverable)
+			{
+				HandlePipelineException(ref response, pipelineException, pipeline, singleNode, seenExceptions);
+			}
+			catch (PipelineException pipelineException)
+			{
+				HandlePipelineException(ref response, pipelineException, pipeline, singleNode, seenExceptions);
+			}
+			catch (Exception killerException)
+			{
+				ThrowUnexpectedTransportException(killerException, seenExceptions, requestData, response, pipeline);
+			}
+		}
+		else
+			foreach (var node in pipeline.NextNode())
+			{
+				requestData.Node = node;
+				try
+				{
+					if (_productRegistration.SupportsSniff) pipeline.SniffOnStaleCluster();
+					if (_productRegistration.SupportsPing) Ping(pipeline, node);
+
+					response = pipeline.CallProductEndpoint<TResponse>(requestData);
+					if (!response.ApiCallDetails.SuccessOrKnownError)
+					{
+						pipeline.MarkDead(node);
+						if (_productRegistration.SupportsSniff) pipeline.SniffOnConnectionFailure();
+					}
+				}
+				catch (PipelineException pipelineException) when (!pipelineException.Recoverable)
+				{
+					HandlePipelineException(ref response, pipelineException, pipeline, node, seenExceptions);
+					break;
+				}
+				catch (PipelineException pipelineException)
+				{
+					HandlePipelineException(ref response, pipelineException, pipeline, node, seenExceptions);
+				}
+				catch (Exception killerException)
+				{
+					ThrowUnexpectedTransportException(killerException, seenExceptions, requestData, response,
+						pipeline);
+				}
+
+				if (response == null || !response.ApiCallDetails.SuccessOrKnownError) continue; // try the next node
+
+				pipeline.MarkAlive(node);
+				break;
+			}
+
+		return FinalizeResponse(requestData, pipeline, seenExceptions, response);
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <typeparam name="TResponse"></typeparam>
+	/// <param name="method"></param>
+	/// <param name="path"></param>
+	/// <param name="data"></param>
+	/// <param name="requestParameters"></param>
+	/// <param name="cancellationToken"></param>
+	/// <returns></returns>
+	/// <exception cref="UnexpectedTransportException"></exception>
+	public override async Task<TResponse> RequestAsync<TResponse>(HttpMethod method, string path,
+		PostData data = null, RequestParameters requestParameters = null,
+		CancellationToken cancellationToken = default)
+	{
+		using var pipeline =
+			PipelineProvider.Create(Settings, DateTimeProvider, MemoryStreamFactory, requestParameters);
+
+		await pipeline.FirstPoolUsageAsync(Settings.BootstrapLock, cancellationToken).ConfigureAwait(false);
+
+		var requestData = new RequestData(method, path, data, Settings, requestParameters, MemoryStreamFactory);
+		Settings.OnRequestDataCreated?.Invoke(requestData);
+		TResponse response = null;
+
+		var seenExceptions = new List<PipelineException>();
+
+		if (pipeline.TryGetSingleNode(out var singleNode))
+		{
+			// No value in marking a single node as dead. We have no other options!
+
+			requestData.Node = singleNode;
+
+			try
+			{
+				response = await pipeline.CallProductEndpointAsync<TResponse>(requestData, cancellationToken)
+					.ConfigureAwait(false);
+			}
+			catch (PipelineException pipelineException) when (!pipelineException.Recoverable)
+			{
+				HandlePipelineException(ref response, pipelineException, pipeline, singleNode, seenExceptions);
+			}
+			catch (PipelineException pipelineException)
+			{
+				HandlePipelineException(ref response, pipelineException, pipeline, singleNode, seenExceptions);
+			}
+			catch (Exception killerException)
+			{
+				ThrowUnexpectedTransportException(killerException, seenExceptions, requestData, response, pipeline);
+			}
+		}
+		else
+			foreach (var node in pipeline.NextNode())
+			{
+				requestData.Node = node;
+				try
+				{
+					if (_productRegistration.SupportsSniff)
+						await pipeline.SniffOnStaleClusterAsync(cancellationToken).ConfigureAwait(false);
+					if (_productRegistration.SupportsPing)
+						await PingAsync(pipeline, node, cancellationToken).ConfigureAwait(false);
+
+					response = await pipeline.CallProductEndpointAsync<TResponse>(requestData, cancellationToken)
+						.ConfigureAwait(false);
+					if (!response.ApiCallDetails.SuccessOrKnownError)
+					{
+						pipeline.MarkDead(node);
+						if (_productRegistration.SupportsSniff)
+							await pipeline.SniffOnConnectionFailureAsync(cancellationToken).ConfigureAwait(false);
+					}
+				}
+				catch (PipelineException pipelineException) when (!pipelineException.Recoverable)
+				{
+					HandlePipelineException(ref response, pipelineException, pipeline, node, seenExceptions);
+					break;
+				}
+				catch (PipelineException pipelineException)
+				{
+					HandlePipelineException(ref response, pipelineException, pipeline, node, seenExceptions);
+				}
+				catch (Exception killerException)
+				{
+					if (killerException is OperationCanceledException && cancellationToken.IsCancellationRequested)
+						pipeline.AuditCancellationRequested();
+
+					throw new UnexpectedTransportException(killerException, seenExceptions)
+					{
+						Request = requestData, ApiCallDetails = response?.ApiCallDetails, AuditTrail = pipeline.AuditTrail
+					};
+				}
+
+				if (cancellationToken.IsCancellationRequested)
+				{
+					pipeline.AuditCancellationRequested();
+					break;
+				}
+
+				if (response == null || !response.ApiCallDetails.SuccessOrKnownError) continue;
+
+				pipeline.MarkAlive(node);
+				break;
+			}
+
+		return FinalizeResponse(requestData, pipeline, seenExceptions, response);
+	}
+	private static void ThrowUnexpectedTransportException<TResponse>(Exception killerException,
+		List<PipelineException> seenExceptions,
+		RequestData requestData,
+		TResponse response, RequestPipeline pipeline
+	) where TResponse : TransportResponse, new() =>
+		throw new UnexpectedTransportException(killerException, seenExceptions)
+		{
+			Request = requestData, ApiCallDetails = response?.ApiCallDetails, AuditTrail = pipeline.AuditTrail
+		};
+
+	private static void HandlePipelineException<TResponse>(
+		ref TResponse response, PipelineException ex, RequestPipeline pipeline, Node node,
+		ICollection<PipelineException> seenExceptions
+	)
+		where TResponse : TransportResponse, new()
+	{
+		response ??= ex.Response as TResponse;
+		pipeline.MarkDead(node);
+		seenExceptions.Add(ex);
+	}
+
+	private TResponse FinalizeResponse<TResponse>(RequestData requestData, RequestPipeline pipeline,
+		List<PipelineException> seenExceptions,
+		TResponse response
+	) where TResponse : TransportResponse, new()
+	{
+		if (requestData.Node == null) //foreach never ran
+			pipeline.ThrowNoNodesAttempted(requestData, seenExceptions);
+
+		var callDetails = GetMostRecentCallDetails(response, seenExceptions);
+		var clientException = pipeline.CreateClientException(response, callDetails, requestData, seenExceptions);
+
+		if (response?.ApiCallDetails == null)
+			pipeline.BadResponse(ref response, callDetails, requestData, clientException);
+
+		HandleTransportException(requestData, clientException, response);
+		return response;
+	}
+
+	private static ApiCallDetails GetMostRecentCallDetails<TResponse>(TResponse response,
+		IEnumerable<PipelineException> seenExceptions)
+		where TResponse : TransportResponse, new()
+	{
+		var callDetails = response?.ApiCallDetails ?? seenExceptions.LastOrDefault(e => e.Response.ApiCallDetails != null)?.Response.ApiCallDetails;
+		return callDetails;
+	}
+
+	// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
+	private void HandleTransportException(RequestData data, Exception clientException, TransportResponse response)
+	{
+		if (response.ApiCallDetails is ApiCallDetails a)
+		{
+			//if original exception was not explicitly set during the pipeline
+			//set it to the TransportException we created for the bad response
+			if (clientException != null && a.OriginalException == null)
+				a.OriginalException = clientException;
+			//On .NET Core the TransportClient implementation throws exceptions on bad responses
+			//This causes it to behave differently to .NET FULL. We already wrapped the WebException
+			//under TransportException and it exposes way more information as part of it's
+			//exception message e.g the the root cause of the server error body.
+#if !DOTNETCORE
+			if (a.OriginalException is WebException)
+				a.OriginalException = clientException;
+#endif
+		}
+
+		Settings.OnRequestCompleted?.Invoke(response.ApiCallDetails);
+		if (data != null && clientException != null && data.ThrowExceptions) throw clientException;
+	}
+
+	private void Ping(RequestPipeline pipeline, Node node)
+	{
+		try
+		{
+			pipeline.Ping(node);
+		}
+		catch (PipelineException e) when (e.Recoverable)
+		{
+			if (_productRegistration.SupportsSniff)
+				pipeline.SniffOnConnectionFailure();
+			throw;
+		}
+	}
+
+	private async Task PingAsync(RequestPipeline pipeline, Node node, CancellationToken cancellationToken)
+	{
+		try
+		{
+			await pipeline.PingAsync(node, cancellationToken).ConfigureAwait(false);
+		}
+		catch (PipelineException e) when (e.Recoverable)
+		{
+			if (_productRegistration.SupportsSniff)
+				await pipeline.SniffOnConnectionFailureAsync(cancellationToken).ConfigureAwait(false);
+			throw;
+		}
+	}
+}
diff --git a/src/Elastic.Transport/Diagnostics/AuditDiagnosticObserver.cs b/src/Elastic.Transport/Diagnostics/AuditDiagnosticObserver.cs
index 4851c0c..ef252b0 100644
--- a/src/Elastic.Transport/Diagnostics/AuditDiagnosticObserver.cs
+++ b/src/Elastic.Transport/Diagnostics/AuditDiagnosticObserver.cs
@@ -6,16 +6,15 @@
 using System.Collections.Generic;
 using Elastic.Transport.Diagnostics.Auditing;
 
-namespace Elastic.Transport.Diagnostics
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary> Provides a typed listener to <see cref="AuditEvent"/> events that <see cref="DefaultRequestPipeline{TConfiguration}"/> emits </summary>
+public sealed class AuditDiagnosticObserver : TypedDiagnosticObserver<Audit>
 {
-	/// <summary> Provides a typed listener to <see cref="AuditEvent"/> events that <see cref="RequestPipeline{TConfiguration}"/> emits </summary>
-	public sealed class AuditDiagnosticObserver : TypedDiagnosticObserver<Audit>
-	{
-		/// <inheritdoc cref="AuditDiagnosticObserver"/>
-		public AuditDiagnosticObserver(
-			Action<KeyValuePair<string, Audit>> onNext,
-			Action<Exception> onError = null,
-			Action onCompleted = null
-		) : base(onNext, onError, onCompleted) { }
-	}
+	/// <inheritdoc cref="AuditDiagnosticObserver"/>
+	public AuditDiagnosticObserver(
+		Action<KeyValuePair<string, Audit>> onNext,
+		Action<Exception> onError = null,
+		Action onCompleted = null
+	) : base(onNext, onError, onCompleted) { }
 }
diff --git a/src/Elastic.Transport/Diagnostics/Auditing/Audit.cs b/src/Elastic.Transport/Diagnostics/Auditing/Audit.cs
index de1915e..b21d641 100644
--- a/src/Elastic.Transport/Diagnostics/Auditing/Audit.cs
+++ b/src/Elastic.Transport/Diagnostics/Auditing/Audit.cs
@@ -5,56 +5,55 @@
 using System;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport.Diagnostics.Auditing
+namespace Elastic.Transport.Diagnostics.Auditing;
+
+/// <summary> An audit of the request made </summary>
+public sealed class Audit
 {
-	/// <summary> An audit of the request made </summary>
-	public sealed class Audit
+	/// <inheritdoc cref="Audit"/>>
+	public Audit(AuditEvent type, DateTime started)
 	{
-		/// <inheritdoc cref="Audit"/>>
-		public Audit(AuditEvent type, DateTime started)
-		{
-			Event = type;
-			Started = started;
-		}
-
-		/// <summary>
-		/// The type of audit event
-		/// </summary>
-		public AuditEvent Event { get; internal set; }
-
-		/// <summary>
-		/// The node on which the request was made
-		/// </summary>
-		public Node Node { get; internal set; }
-
-		/// <summary>
-		/// The path of the request
-		/// </summary>
-		public string Path { get; internal set; }
-
-		/// <summary>
-		/// The end date and time of the audit
-		/// </summary>
-		public DateTime Ended { get; internal set; }
-
-		/// <summary>
-		/// The start date and time of the audit
-		/// </summary>
-		public DateTime Started { get; }
-
-		/// <summary>
-		/// The exception for the audit, if there was one.
-		/// </summary>
-		public Exception Exception { get; internal set; }
-
-		/// <summary> Returns a string representation of the this audit</summary>
-		public override string ToString()
-		{
-			var took = Ended - Started;
-			var tookString = string.Empty;
-			if (took >= TimeSpan.Zero) tookString = $" Took: {took}";
-
-			return Node == null ? $"Event: {Event.GetStringValue()}{tookString}" : $"Event: {Event.GetStringValue()} Node: {Node?.Uri} NodeAlive: {Node?.IsAlive}Took: {tookString}";
-		}
+		Event = type;
+		Started = started;
+	}
+
+	/// <summary>
+	/// The type of audit event
+	/// </summary>
+	public AuditEvent Event { get; internal set; }
+
+	/// <summary>
+	/// The node on which the request was made
+	/// </summary>
+	public Node Node { get; internal set; }
+
+	/// <summary>
+	/// The path of the request
+	/// </summary>
+	public string Path { get; internal set; }
+
+	/// <summary>
+	/// The end date and time of the audit
+	/// </summary>
+	public DateTime Ended { get; internal set; }
+
+	/// <summary>
+	/// The start date and time of the audit
+	/// </summary>
+	public DateTime Started { get; }
+
+	/// <summary>
+	/// The exception for the audit, if there was one.
+	/// </summary>
+	public Exception Exception { get; internal set; }
+
+	/// <summary> Returns a string representation of the this audit</summary>
+	public override string ToString()
+	{
+		var took = Ended - Started;
+		var tookString = string.Empty;
+		if (took >= TimeSpan.Zero) tookString = $" Took: {took}";
+
+		return Node == null ? $"Event: {Event.GetStringValue()}{tookString}" : $"Event: {Event.GetStringValue()} Node: {Node?.Uri} NodeAlive: {Node?.IsAlive}Took: {tookString}";
 	}
 }
diff --git a/src/Elastic.Transport/Diagnostics/Auditing/AuditEvent.cs b/src/Elastic.Transport/Diagnostics/Auditing/AuditEvent.cs
index 63aaf6b..e2716ef 100644
--- a/src/Elastic.Transport/Diagnostics/Auditing/AuditEvent.cs
+++ b/src/Elastic.Transport/Diagnostics/Auditing/AuditEvent.cs
@@ -2,90 +2,89 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport.Diagnostics.Auditing
+namespace Elastic.Transport.Diagnostics.Auditing;
+
+/// <summary>
+/// Enumeration of different auditable events that can occur in the execution of
+/// <see cref="HttpTransport.RequestAsync{TResponse}"/> as modeled by
+/// <see cref="RequestPipeline"/>.
+/// </summary>
+public enum AuditEvent
 {
+	/// <summary> The request performed the first sniff on startup of the client </summary>
+	SniffOnStartup,
+
+	/// <summary> The request saw a failure on a node and a sniff occurred as a result of it</summary>
+	SniffOnFail,
+
+	/// <summary> The cluster state expired and a sniff occurred as a result of it</summary>
+	SniffOnStaleCluster,
+
+	/// <summary>A sniff that was initiated was successful</summary>
+	SniffSuccess,
+
+	/// <summary>A sniff that was initiated resulted in a failure</summary>
+	SniffFailure,
+
+	/// <summary>A ping that was initiated was successful</summary>
+	PingSuccess,
+
+	/// <summary>A ping that was initiated resulted in a failure</summary>
+	PingFailure,
+
+	/// <summary>A node that was previously marked dead was put back in the regular rotation</summary>
+	Resurrection,
+
+	/// <summary>
+	/// All nodes returned by <see cref="NodePool.CreateView"/> are marked dead (see <see cref="Node.IsAlive"/>)
+	/// After this event a random node is resurrected and tried by force
+	/// </summary>
+	AllNodesDead,
+
+	/// <summary>
+	/// A call into <see cref="RequestPipeline.CallProductEndpointAsync{TResponse}"/> resulted in a failure
+	/// </summary>
+	BadResponse,
+
+	/// <summary>
+	/// A call into <see cref="RequestPipeline.CallProductEndpointAsync{TResponse}"/> resulted in a success
+	/// </summary>
+	HealthyResponse,
+
+	/// <summary>
+	/// The call into <see cref="HttpTransport.Request{TResponse}"/> took too long.
+	/// This could mean the call was retried but retrying was to slow and cumulative this exceeded
+	/// <see cref="ITransportConfiguration.MaxRetryTimeout"/>
+	/// </summary>
+	MaxTimeoutReached,
+
+	/// <summary>
+	/// The call into <see cref="HttpTransport.Request{TResponse}"/> was not able to complete
+	/// successfully and exceeded the available retries as configured on
+	/// <see cref="ITransportConfiguration.MaxRetries"/>.
+	/// </summary>
+	MaxRetriesReached,
+
+	/// <summary>
+	/// A call into <see cref="RequestPipeline.CallProductEndpointAsync{TResponse}"/> failed before a response was
+	/// received.
+	/// </summary>
+	BadRequest,
+
+	/// <summary>
+	/// Rare but if <see cref="ITransportConfiguration.NodePredicate"/> is too stringent and node nodes in
+	/// the <see cref="NodePool.Nodes"/> satisfies this predicate this will result in this failure.
+	/// </summary>
+	NoNodesAttempted,
+
+	/// <summary>
+	/// Signals the audit may be incomplete because cancellation was requested on the async paths
+	/// </summary>
+	CancellationRequested,
+
 	/// <summary>
-	/// Enumeration of different auditable events that can occur in the execution of
-	/// <see cref="ITransport.RequestAsync{TResponse}"/> as modeled by
-	/// <see cref="IRequestPipeline"/>.
+	/// The request failed within the allotted <see cref="ITransportConfiguration.MaxRetryTimeout"/> but failed
+	/// on all the available <see cref="NodePool.Nodes"/>
 	/// </summary>
-	public enum AuditEvent
-	{
-		/// <summary> The request performed the first sniff on startup of the client </summary>
-		SniffOnStartup,
-
-		/// <summary> The request saw a failure on a node and a sniff occurred as a result of it</summary>
-		SniffOnFail,
-
-		/// <summary> The cluster state expired and a sniff occurred as a result of it</summary>
-		SniffOnStaleCluster,
-
-		/// <summary>A sniff that was initiated was successful</summary>
-		SniffSuccess,
-
-		/// <summary>A sniff that was initiated resulted in a failure</summary>
-		SniffFailure,
-
-		/// <summary>A ping that was initiated was successful</summary>
-		PingSuccess,
-
-		/// <summary>A ping that was initiated resulted in a failure</summary>
-		PingFailure,
-
-		/// <summary>A node that was previously marked dead was put back in the regular rotation</summary>
-		Resurrection,
-
-		/// <summary>
-		/// All nodes returned by <see cref="NodePool.CreateView"/> are marked dead (see <see cref="Node.IsAlive"/>)
-		/// After this event a random node is resurrected and tried by force
-		/// </summary>
-		AllNodesDead,
-
-		/// <summary>
-		/// A call into <see cref="IRequestPipeline.CallProductEndpointAsync{TResponse}"/> resulted in a failure
-		/// </summary>
-		BadResponse,
-
-		/// <summary>
-		/// A call into <see cref="IRequestPipeline.CallProductEndpointAsync{TResponse}"/> resulted in a success
-		/// </summary>
-		HealthyResponse,
-
-		/// <summary>
-		/// The call into <see cref="ITransport.Request{TResponse}"/> took too long.
-		/// This could mean the call was retried but retrying was to slow and cumulative this exceeded
-		/// <see cref="ITransportConfiguration.MaxRetryTimeout"/>
-		/// </summary>
-		MaxTimeoutReached,
-
-		/// <summary>
-		/// The call into <see cref="ITransport.Request{TResponse}"/> was not able to complete
-		/// successfully and exceeded the available retries as configured on
-		/// <see cref="ITransportConfiguration.MaxRetries"/>.
-		/// </summary>
-		MaxRetriesReached,
-
-		/// <summary>
-		/// A call into <see cref="IRequestPipeline.CallProductEndpointAsync{TResponse}"/> failed before a response was
-		/// received.
-		/// </summary>
-		BadRequest,
-
-		/// <summary>
-		/// Rare but if <see cref="ITransportConfiguration.NodePredicate"/> is too stringent and node nodes in
-		/// the <see cref="NodePool.Nodes"/> satisfies this predicate this will result in this failure.
-		/// </summary>
-		NoNodesAttempted,
-
-		/// <summary>
-		/// Signals the audit may be incomplete because cancellation was requested on the async paths
-		/// </summary>
-		CancellationRequested,
-
-		/// <summary>
-		/// The request failed within the allotted <see cref="ITransportConfiguration.MaxRetryTimeout"/> but failed
-		/// on all the available <see cref="NodePool.Nodes"/>
-		/// </summary>
-		FailedOverAllNodes,
-	}
+	FailedOverAllNodes,
 }
diff --git a/src/Elastic.Transport/Diagnostics/Auditing/AuditEventExtensions.cs b/src/Elastic.Transport/Diagnostics/Auditing/AuditEventExtensions.cs
index 4a88220..43bae54 100644
--- a/src/Elastic.Transport/Diagnostics/Auditing/AuditEventExtensions.cs
+++ b/src/Elastic.Transport/Diagnostics/Auditing/AuditEventExtensions.cs
@@ -5,40 +5,39 @@
 using System.Diagnostics;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport.Diagnostics.Auditing
+namespace Elastic.Transport.Diagnostics.Auditing;
+
+internal static class AuditEventExtensions
 {
-	internal static class AuditEventExtensions
+	/// <summary>
+	/// Returns the name of the event to be used for use in <see cref="DiagnosticSource"/>.
+	/// <para>If this return null the event should not be reported on</para>
+	/// <para>This indicates this event is monitored by a different component already</para>
+	/// </summary>
+	/// <returns>The diagnostic event name representation or null if it should go unreported</returns>
+	public static string GetAuditDiagnosticEventName(this AuditEvent @event)
 	{
-		/// <summary>
-		/// Returns the name of the event to be used for use in <see cref="DiagnosticSource"/>.
-		/// <para>If this return null the event should not be reported on</para>
-		/// <para>This indicates this event is monitored by a different component already</para>
-		/// </summary>
-		/// <returns>The diagnostic event name representation or null if it should go unreported</returns>
-		public static string GetAuditDiagnosticEventName(this AuditEvent @event)
+		switch(@event)
 		{
-			switch(@event)
-			{
-				case AuditEvent.SniffFailure:
-				case AuditEvent.SniffSuccess:
-				case AuditEvent.PingFailure:
-				case AuditEvent.PingSuccess:
-				case AuditEvent.BadResponse:
-				case AuditEvent.HealthyResponse:
-					return null;
-				case AuditEvent.SniffOnStartup: return nameof(AuditEvent.SniffOnStartup);
-				case AuditEvent.SniffOnFail: return nameof(AuditEvent.SniffOnFail);
-				case AuditEvent.SniffOnStaleCluster: return nameof(AuditEvent.SniffOnStaleCluster);
-				case AuditEvent.Resurrection: return nameof(AuditEvent.Resurrection);
-				case AuditEvent.AllNodesDead: return nameof(AuditEvent.AllNodesDead);
-				case AuditEvent.MaxTimeoutReached: return nameof(AuditEvent.MaxTimeoutReached);
-				case AuditEvent.MaxRetriesReached: return nameof(AuditEvent.MaxRetriesReached);
-				case AuditEvent.BadRequest: return nameof(AuditEvent.BadRequest);
-				case AuditEvent.NoNodesAttempted: return nameof(AuditEvent.NoNodesAttempted);
-				case AuditEvent.CancellationRequested: return nameof(AuditEvent.CancellationRequested);
-				case AuditEvent.FailedOverAllNodes: return nameof(AuditEvent.FailedOverAllNodes);
-				default: return @event.GetStringValue(); //still cached but uses reflection
-			}
+			case AuditEvent.SniffFailure:
+			case AuditEvent.SniffSuccess:
+			case AuditEvent.PingFailure:
+			case AuditEvent.PingSuccess:
+			case AuditEvent.BadResponse:
+			case AuditEvent.HealthyResponse:
+				return null;
+			case AuditEvent.SniffOnStartup: return nameof(AuditEvent.SniffOnStartup);
+			case AuditEvent.SniffOnFail: return nameof(AuditEvent.SniffOnFail);
+			case AuditEvent.SniffOnStaleCluster: return nameof(AuditEvent.SniffOnStaleCluster);
+			case AuditEvent.Resurrection: return nameof(AuditEvent.Resurrection);
+			case AuditEvent.AllNodesDead: return nameof(AuditEvent.AllNodesDead);
+			case AuditEvent.MaxTimeoutReached: return nameof(AuditEvent.MaxTimeoutReached);
+			case AuditEvent.MaxRetriesReached: return nameof(AuditEvent.MaxRetriesReached);
+			case AuditEvent.BadRequest: return nameof(AuditEvent.BadRequest);
+			case AuditEvent.NoNodesAttempted: return nameof(AuditEvent.NoNodesAttempted);
+			case AuditEvent.CancellationRequested: return nameof(AuditEvent.CancellationRequested);
+			case AuditEvent.FailedOverAllNodes: return nameof(AuditEvent.FailedOverAllNodes);
+			default: return @event.GetStringValue(); //still cached but uses reflection
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Diagnostics/Auditing/Auditable.cs b/src/Elastic.Transport/Diagnostics/Auditing/Auditable.cs
index 45cdcef..3aa7da2 100644
--- a/src/Elastic.Transport/Diagnostics/Auditing/Auditable.cs
+++ b/src/Elastic.Transport/Diagnostics/Auditing/Auditable.cs
@@ -6,48 +6,47 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 
-namespace Elastic.Transport.Diagnostics.Auditing
+namespace Elastic.Transport.Diagnostics.Auditing;
+
+internal class Auditable : IDisposable
 {
-	internal class Auditable : IDisposable
+	private readonly Audit _audit;
+	private readonly IDisposable _activity;
+	private readonly DateTimeProvider _dateTimeProvider;
+	private static DiagnosticSource DiagnosticSource { get; } = new DiagnosticListener(DiagnosticSources.AuditTrailEvents.SourceName);
+
+	public Auditable(AuditEvent type, List<Audit> auditTrail, DateTimeProvider dateTimeProvider, Node node)
 	{
-		private readonly Audit _audit;
-		private readonly IDisposable _activity;
-		private readonly IDateTimeProvider _dateTimeProvider;
-		private static DiagnosticSource DiagnosticSource { get; } = new DiagnosticListener(DiagnosticSources.AuditTrailEvents.SourceName);
+		_dateTimeProvider = dateTimeProvider;
+		var started = _dateTimeProvider.Now();
 
-		public Auditable(AuditEvent type, List<Audit> auditTrail, IDateTimeProvider dateTimeProvider, Node node)
+		_audit = new Audit(type, started)
 		{
-			_dateTimeProvider = dateTimeProvider;
-			var started = _dateTimeProvider.Now();
-
-			_audit = new Audit(type, started)
-			{
-				Node = node
-			};
-			auditTrail.Add(_audit);
-			var diagnosticName = type.GetAuditDiagnosticEventName();
-			_activity = diagnosticName != null ? DiagnosticSource.Diagnose(diagnosticName, _audit) : null;
-		}
-
-		public AuditEvent Event
-		{
-			set => _audit.Event = value;
-		}
+			Node = node
+		};
+		auditTrail.Add(_audit);
+		var diagnosticName = type.GetAuditDiagnosticEventName();
+		_activity = diagnosticName != null ? DiagnosticSource.Diagnose(diagnosticName, _audit) : null;
+	}
 
-		public Exception Exception
-		{
-			set => _audit.Exception = value;
-		}
+	public AuditEvent Event
+	{
+		set => _audit.Event = value;
+	}
 
-		public string Path
-		{
-			set => _audit.Path = value;
-		}
+	public Exception Exception
+	{
+		set => _audit.Exception = value;
+	}
 
-		public void Dispose()
-		{
-			_audit.Ended = _dateTimeProvider.Now();
-			_activity?.Dispose();
-		}
+	public string Path
+	{
+		set => _audit.Path = value;
+	}
+
+	public void Dispose()
+	{
+		_audit.Ended = _dateTimeProvider.Now();
+		_activity?.Dispose();
 	}
 }
diff --git a/src/Elastic.Transport/Diagnostics/Diagnostic.cs b/src/Elastic.Transport/Diagnostics/Diagnostic.cs
index 58c7921..daeb81c 100644
--- a/src/Elastic.Transport/Diagnostics/Diagnostic.cs
+++ b/src/Elastic.Transport/Diagnostics/Diagnostic.cs
@@ -5,60 +5,59 @@
 using System;
 using System.Diagnostics;
 
-namespace Elastic.Transport.Diagnostics
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary>
+/// Internal subclass of <see cref="Activity"/> that implements <see cref="IDisposable"/> to
+/// make it easier to use.
+/// </summary>
+internal class Diagnostic<TState> : Diagnostic<TState, TState>
 {
-	/// <summary>
-	/// Internal subclass of <see cref="Activity"/> that implements <see cref="IDisposable"/> to
-	/// make it easier to use.
-	/// </summary>
-	internal class Diagnostic<TState> : Diagnostic<TState, TState>
-	{
-		public Diagnostic(string operationName, DiagnosticSource source, TState state)
-			: base(operationName, source, state) =>
-			EndState = state;
-	}
+	public Diagnostic(string operationName, DiagnosticSource source, TState state)
+		: base(operationName, source, state) =>
+		EndState = state;
+}
 
-	internal class Diagnostic<TState, TStateEnd> : Activity, IDisposable
-	{
-		public static Diagnostic<TState, TStateEnd> Default { get; } = new Diagnostic<TState, TStateEnd>();
+internal class Diagnostic<TState, TStateEnd> : Activity, IDisposable
+{
+	public static Diagnostic<TState, TStateEnd> Default { get; } = new Diagnostic<TState, TStateEnd>();
 
-		private readonly DiagnosticSource _source;
-		private TStateEnd _endState;
-		private readonly bool _default;
-		private bool _disposed;
+	private readonly DiagnosticSource _source;
+	private TStateEnd _endState;
+	private readonly bool _default;
+	private bool _disposed;
 
-		private Diagnostic() : base("__NOOP__") => _default = true;
+	private Diagnostic() : base("__NOOP__") => _default = true;
 
-		public Diagnostic(string operationName, DiagnosticSource source, TState state) : base(operationName)
-		{
-			_source = source;
-			_source.StartActivity(SetStartTime(DateTime.UtcNow), state);
-		}
+	public Diagnostic(string operationName, DiagnosticSource source, TState state) : base(operationName)
+	{
+		_source = source;
+		_source.StartActivity(SetStartTime(DateTime.UtcNow), state);
+	}
 
-		public TStateEnd EndState
+	public TStateEnd EndState
+	{
+		get => _endState;
+		internal set
 		{
-			get => _endState;
-			internal set
-			{
-				//do not store state on default instance
-				if (_default) return;
-				_endState =  value;
-			}
+			//do not store state on default instance
+			if (_default) return;
+			_endState =  value;
 		}
+	}
 
-		protected override void Dispose(bool disposing)
-		{
-			if (_disposed) return;
+	protected override void Dispose(bool disposing)
+	{
+		if (_disposed) return;
 
-			if (disposing)
-			{
-				//_source can be null if Default instance
-				_source?.StopActivity(SetEndTime(DateTime.UtcNow), EndState);
-			}
+		if (disposing)
+		{
+			//_source can be null if Default instance
+			_source?.StopActivity(SetEndTime(DateTime.UtcNow), EndState);
+		}
 
-			_disposed = true;
+		_disposed = true;
 
-			base.Dispose(disposing);
-		}
+		base.Dispose(disposing);
 	}
 }
diff --git a/src/Elastic.Transport/Diagnostics/DiagnosticSources.cs b/src/Elastic.Transport/Diagnostics/DiagnosticSources.cs
index b2317b6..3734f61 100644
--- a/src/Elastic.Transport/Diagnostics/DiagnosticSources.cs
+++ b/src/Elastic.Transport/Diagnostics/DiagnosticSources.cs
@@ -6,136 +6,135 @@
 using System.Diagnostics;
 using Elastic.Transport.Diagnostics.Auditing;
 
-namespace Elastic.Transport.Diagnostics
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary>
+/// Provides public access to the strings used while emitting diagnostics.
+/// This makes wiring up <see cref="DiagnosticListener"/>'s less error prone and eliminates magic strings
+/// </summary>
+public static class DiagnosticSources
 {
 	/// <summary>
-	/// Provides public access to the strings used while emitting diagnostics.
-	/// This makes wiring up <see cref="DiagnosticListener"/>'s less error prone and eliminates magic strings
+	/// When subscribing to <see cref="AuditDiagnosticKeys.SourceName"/> you will be notified of all decisions in the request pipeline
 	/// </summary>
-	public static class DiagnosticSources
-	{
-		/// <summary>
-		/// When subscribing to <see cref="AuditDiagnosticKeys.SourceName"/> you will be notified of all decisions in the request pipeline
-		/// </summary>
-		public static AuditDiagnosticKeys AuditTrailEvents { get; } = new AuditDiagnosticKeys();
+	public static AuditDiagnosticKeys AuditTrailEvents { get; } = new AuditDiagnosticKeys();
 
-		/// <summary>
-		/// When subscribing to <see cref="RequestPipelineDiagnosticKeys.SourceName"/> you will be notified every time a sniff/ping or an API call to Elasticsearch happens
-		/// </summary>
-		public static RequestPipelineDiagnosticKeys RequestPipeline { get; } = new RequestPipelineDiagnosticKeys();
+	/// <summary>
+	/// When subscribing to <see cref="RequestPipelineDiagnosticKeys.SourceName"/> you will be notified every time a sniff/ping or an API call to Elasticsearch happens
+	/// </summary>
+	public static RequestPipelineDiagnosticKeys RequestPipeline { get; } = new RequestPipelineDiagnosticKeys();
 
-		/// <summary>
-		/// When subscribing to <see cref="HttpConnectionDiagnosticKeys.SourceName"/> you will be notified every time a a connection starts and stops a request and starts and stops a a response
-		/// </summary>
-		public static HttpConnectionDiagnosticKeys HttpConnection { get; } = new HttpConnectionDiagnosticKeys();
+	/// <summary>
+	/// When subscribing to <see cref="HttpConnectionDiagnosticKeys.SourceName"/> you will be notified every time a a connection starts and stops a request and starts and stops a a response
+	/// </summary>
+	public static HttpConnectionDiagnosticKeys HttpConnection { get; } = new HttpConnectionDiagnosticKeys();
+
+	/// <summary>
+	/// When subscribing to <see cref="SerializerDiagnosticKeys.SourceName"/> you will be notified every time a particular serializer writes or reads
+	/// </summary>
+	public static SerializerDiagnosticKeys Serializer { get; } = new SerializerDiagnosticKeys();
 
+	private interface IDiagnosticsKeys
+	{
+		// ReSharper disable once UnusedMemberInSuper.Global
 		/// <summary>
-		/// When subscribing to <see cref="SerializerDiagnosticKeys.SourceName"/> you will be notified every time a particular serializer writes or reads
+		/// The source name to enable to receive diagnostic data for this <see cref="DiagnosticSource"/>
 		/// </summary>
-		public static SerializerDiagnosticKeys Serializer { get; } = new SerializerDiagnosticKeys();
+		string SourceName { get; }
+	}
 
-		private interface IDiagnosticsKeys
-		{
-			// ReSharper disable once UnusedMemberInSuper.Global
-			/// <summary>
-			/// The source name to enable to receive diagnostic data for this <see cref="DiagnosticSource"/>
-			/// </summary>
-			string SourceName { get; }
-		}
+	/// <summary>
+	/// Provides access to the string event names related to <see cref="HttpConnection"/> the default
+	/// <see cref="TransportClient"/> implementation.
+	/// </summary>
+	public class HttpConnectionDiagnosticKeys : IDiagnosticsKeys
+	{
+		/// <inheritdoc cref="IDiagnosticsKeys.SourceName"/>
+		public string SourceName { get; } = typeof(HttpTransportClient).FullName;
 
-		/// <summary>
-		/// Provides access to the string event names related to <see cref="HttpConnection"/> the default
-		/// <see cref="ITransportClient"/> implementation.
-		/// </summary>
-		public class HttpConnectionDiagnosticKeys : IDiagnosticsKeys
-		{
-			/// <inheritdoc cref="IDiagnosticsKeys.SourceName"/>
-			public string SourceName { get; } = typeof(HttpTransportClient).FullName;
+		/// <summary> Start and stop event initiating the request and sending and receiving the headers</summary>
+		public string SendAndReceiveHeaders { get; } = nameof(SendAndReceiveHeaders);
 
-			/// <summary> Start and stop event initiating the request and sending and receiving the headers</summary>
-			public string SendAndReceiveHeaders { get; } = nameof(SendAndReceiveHeaders);
+		/// <summary> Start and stop event that tracks receiving the body</summary>
+		public string ReceiveBody { get; } = nameof(ReceiveBody);
+	}
 
-			/// <summary> Start and stop event that tracks receiving the body</summary>
-			public string ReceiveBody { get; } = nameof(ReceiveBody);
-		}
+	/// <summary>
+	/// Provides access to the string event names related to <see cref="DiagnosticsSerializerProxy"/> which
+	/// internally wraps any configured <see cref="Elastic.Transport.Serializer"/>
+	/// </summary>
+	public class SerializerDiagnosticKeys : IDiagnosticsKeys
+	{
+		/// <inheritdoc cref="IDiagnosticsKeys.SourceName"/>
+		public string SourceName { get; } = typeof(Serializer).FullName;
 
-		/// <summary>
-		/// Provides access to the string event names related to <see cref="DiagnosticsSerializerProxy"/> which
-		/// internally wraps any configured <see cref="Elastic.Transport.Serializer"/>
-		/// </summary>
-		public class SerializerDiagnosticKeys : IDiagnosticsKeys
-		{
-			/// <inheritdoc cref="IDiagnosticsKeys.SourceName"/>
-			public string SourceName { get; } = typeof(Serializer).FullName;
+		/// <summary> Start and stop event around <see cref="Serializer.Serialize{T}"/> invocations</summary>
+		public string Serialize { get; } = nameof(Serialize);
 
-			/// <summary> Start and stop event around <see cref="Serializer.Serialize{T}"/> invocations</summary>
-			public string Serialize { get; } = nameof(Serialize);
+		/// <summary> Start and stop event around <see cref="Serializer.Deserialize{T}"/> invocations</summary>
+		public string Deserialize { get; } = nameof(Deserialize);
+	}
 
-			/// <summary> Start and stop event around <see cref="Serializer.Deserialize{T}"/> invocations</summary>
-			public string Deserialize { get; } = nameof(Deserialize);
-		}
+	/// <summary>
+	/// Provides access to the string event names that <see cref="RequestPipeline"/> emits
+	/// </summary>
+	public class RequestPipelineDiagnosticKeys : IDiagnosticsKeys
+	{
+		/// <inheritdoc cref="IDiagnosticsKeys.SourceName"/>
+		public string SourceName { get; } = "RequestPipeline";
 
 		/// <summary>
-		/// Provides access to the string event names that <see cref="RequestPipeline"/> emits
+		/// Start and stop event around <see cref="RequestPipeline.CallProductEndpoint{TResponse}"/> invocations
 		/// </summary>
-		public class RequestPipelineDiagnosticKeys : IDiagnosticsKeys
-		{
-			/// <inheritdoc cref="IDiagnosticsKeys.SourceName"/>
-			public string SourceName { get; } = "RequestPipeline";
+		public string CallProductEndpoint { get; } = nameof(CallProductEndpoint);
 
-			/// <summary>
-			/// Start and stop event around <see cref="IRequestPipeline.CallProductEndpoint{TResponse}"/> invocations
-			/// </summary>
-			public string CallProductEndpoint { get; } = nameof(CallProductEndpoint);
+		/// <summary> Start and stop event around <see cref="RequestPipeline.Ping"/> invocations</summary>
+		public string Ping { get; } = nameof(Ping);
 
-			/// <summary> Start and stop event around <see cref="IRequestPipeline.Ping"/> invocations</summary>
-			public string Ping { get; } = nameof(Ping);
+		/// <summary> Start and stop event around <see cref="RequestPipeline.Sniff"/> invocations</summary>
+		public string Sniff { get; } = nameof(Sniff);
+	}
 
-			/// <summary> Start and stop event around <see cref="IRequestPipeline.Sniff"/> invocations</summary>
-			public string Sniff { get; } = nameof(Sniff);
-		}
+	/// <summary>
+	/// Reference to the diagnostic source name that allows you to listen to all decisions that
+	/// <see cref="RequestPipeline"/> makes. Events it emits are the names on <see cref="AuditEvent"/>
+	/// </summary>
+	public class AuditDiagnosticKeys : IDiagnosticsKeys
+	{
+		/// <inheritdoc cref="IDiagnosticsKeys.SourceName"/>
+		public string SourceName { get; } = typeof(Audit).FullName;
+	}
 
-		/// <summary>
-		/// Reference to the diagnostic source name that allows you to listen to all decisions that
-		/// <see cref="IRequestPipeline"/> makes. Events it emits are the names on <see cref="AuditEvent"/>
-		/// </summary>
-		public class AuditDiagnosticKeys : IDiagnosticsKeys
-		{
-			/// <inheritdoc cref="IDiagnosticsKeys.SourceName"/>
-			public string SourceName { get; } = typeof(Audit).FullName;
-		}
+	internal class EmptyDisposable : IDisposable
+	{
+		public void Dispose() { }
+	}
 
-		internal class EmptyDisposable : IDisposable
-		{
-			public void Dispose() { }
-		}
+	internal static EmptyDisposable SingletonDisposable { get; } = new EmptyDisposable();
 
-		internal static EmptyDisposable SingletonDisposable { get; } = new EmptyDisposable();
+	internal static IDisposable Diagnose<TState>(this DiagnosticSource source, string operationName, TState state)
+	{
+		if (!source.IsEnabled(operationName)) return SingletonDisposable;
 
-		internal static IDisposable Diagnose<TState>(this DiagnosticSource source, string operationName, TState state)
-		{
-			if (!source.IsEnabled(operationName)) return SingletonDisposable;
+		return new Diagnostic<TState>(operationName, source, state);
+	}
 
-			return new Diagnostic<TState>(operationName, source, state);
-		}
+	internal static Diagnostic<TState, TStateStop> Diagnose<TState, TStateStop>(this DiagnosticSource source, string operationName, TState state)
+	{
+		if (!source.IsEnabled(operationName)) return Diagnostic<TState, TStateStop>.Default;
 
-		internal static Diagnostic<TState, TStateStop> Diagnose<TState, TStateStop>(this DiagnosticSource source, string operationName, TState state)
-		{
-			if (!source.IsEnabled(operationName)) return Diagnostic<TState, TStateStop>.Default;
+		return new Diagnostic<TState, TStateStop>(operationName, source, state);
+	}
 
-			return new Diagnostic<TState, TStateStop>(operationName, source, state);
-		}
+	internal static Diagnostic<TState, TEndState> Diagnose<TState, TEndState>(this DiagnosticSource source, string operationName, TState state, TEndState endState)
+	{
+		if (!source.IsEnabled(operationName)) return Diagnostic<TState, TEndState>.Default;
 
-		internal static Diagnostic<TState, TEndState> Diagnose<TState, TEndState>(this DiagnosticSource source, string operationName, TState state, TEndState endState)
+		return new Diagnostic<TState, TEndState>(operationName, source, state)
 		{
-			if (!source.IsEnabled(operationName)) return Diagnostic<TState, TEndState>.Default;
-
-			return new Diagnostic<TState, TEndState>(operationName, source, state)
-			{
-				EndState = endState
-			};
-
-		}
+			EndState = endState
+		};
 
 	}
+
 }
diff --git a/src/Elastic.Transport/Diagnostics/HttpConnectionDiagnosticObserver.cs b/src/Elastic.Transport/Diagnostics/HttpConnectionDiagnosticObserver.cs
index 6e4f02e..178d3d9 100644
--- a/src/Elastic.Transport/Diagnostics/HttpConnectionDiagnosticObserver.cs
+++ b/src/Elastic.Transport/Diagnostics/HttpConnectionDiagnosticObserver.cs
@@ -5,18 +5,17 @@
 using System;
 using System.Collections.Generic;
 
-namespace Elastic.Transport.Diagnostics
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary> Provides a typed listener to the events that <see cref="HttpTransportClient"/> emits </summary>
+public sealed class HttpConnectionDiagnosticObserver : TypedDiagnosticObserver<RequestData, int?>
 {
-	/// <summary> Provides a typed listener to the events that <see cref="HttpTransportClient"/> emits </summary>
-	public sealed class HttpConnectionDiagnosticObserver : TypedDiagnosticObserver<RequestData, int?>
-	{
-		/// <inheritdoc cref="HttpConnectionDiagnosticObserver"/>>
-		public HttpConnectionDiagnosticObserver(
-			Action<KeyValuePair<string, RequestData>> onNextStart,
-			Action<KeyValuePair<string, int?>> onNextEnd,
-			Action<Exception> onError = null,
-			Action onCompleted = null
-		) : base(onNextStart, onNextEnd, onError, onCompleted) { }
+	/// <inheritdoc cref="HttpConnectionDiagnosticObserver"/>>
+	public HttpConnectionDiagnosticObserver(
+		Action<KeyValuePair<string, RequestData>> onNextStart,
+		Action<KeyValuePair<string, int?>> onNextEnd,
+		Action<Exception> onError = null,
+		Action onCompleted = null
+	) : base(onNextStart, onNextEnd, onError, onCompleted) { }
 
-	}
 }
diff --git a/src/Elastic.Transport/Diagnostics/RequestPipelineDiagnosticObserver.cs b/src/Elastic.Transport/Diagnostics/RequestPipelineDiagnosticObserver.cs
index 4a53f61..1611295 100644
--- a/src/Elastic.Transport/Diagnostics/RequestPipelineDiagnosticObserver.cs
+++ b/src/Elastic.Transport/Diagnostics/RequestPipelineDiagnosticObserver.cs
@@ -5,18 +5,17 @@
 using System;
 using System.Collections.Generic;
 
-namespace Elastic.Transport.Diagnostics
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary> Provides a typed listener to  actions that <see cref="DefaultRequestPipeline{TConfiguration}"/> takes e.g sniff, ping, or making an API call </summary>;
+public sealed class RequestPipelineDiagnosticObserver : TypedDiagnosticObserver<RequestData, ApiCallDetails>
 {
-	/// <summary> Provides a typed listener to  actions that <see cref="RequestPipeline{TConfiguration}"/> takes e.g sniff, ping, or making an API call </summary>;
-	public sealed class RequestPipelineDiagnosticObserver : TypedDiagnosticObserver<RequestData, IApiCallDetails>
-	{
-		/// <inheritdoc cref="RequestPipelineDiagnosticObserver"/>
-		public RequestPipelineDiagnosticObserver(
-			Action<KeyValuePair<string, RequestData>> onNextStart,
-			Action<KeyValuePair<string, IApiCallDetails>> onNextEnd,
-			Action<Exception> onError = null,
-			Action onCompleted = null
-		) : base(onNextStart, onNextEnd, onError, onCompleted) { }
+	/// <inheritdoc cref="RequestPipelineDiagnosticObserver"/>
+	public RequestPipelineDiagnosticObserver(
+		Action<KeyValuePair<string, RequestData>> onNextStart,
+		Action<KeyValuePair<string, ApiCallDetails>> onNextEnd,
+		Action<Exception> onError = null,
+		Action onCompleted = null
+	) : base(onNextStart, onNextEnd, onError, onCompleted) { }
 
-	}
 }
diff --git a/src/Elastic.Transport/Diagnostics/SerializerDiagnosticObserver.cs b/src/Elastic.Transport/Diagnostics/SerializerDiagnosticObserver.cs
index 1f958ce..142532d 100644
--- a/src/Elastic.Transport/Diagnostics/SerializerDiagnosticObserver.cs
+++ b/src/Elastic.Transport/Diagnostics/SerializerDiagnosticObserver.cs
@@ -5,16 +5,15 @@
 using System;
 using System.Collections.Generic;
 
-namespace Elastic.Transport.Diagnostics
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary> Provides a typed listener any time an <see cref="Serializer"/> does a write or read</summary>
+public sealed class SerializerDiagnosticObserver : TypedDiagnosticObserver<SerializerRegistrationInformation>
 {
-	/// <summary> Provides a typed listener any time an <see cref="Serializer"/> does a write or read</summary>
-	public sealed class SerializerDiagnosticObserver : TypedDiagnosticObserver<SerializerRegistrationInformation>
-	{
-		/// <inheritdoc cref="SerializerDiagnosticObserver"/>
-		public SerializerDiagnosticObserver(
-			Action<KeyValuePair<string, SerializerRegistrationInformation>> onNext,
-			Action<Exception> onError = null,
-			Action onCompleted = null
-		) : base(onNext, onError, onCompleted) { }
-	}
+	/// <inheritdoc cref="SerializerDiagnosticObserver"/>
+	public SerializerDiagnosticObserver(
+		Action<KeyValuePair<string, SerializerRegistrationInformation>> onNext,
+		Action<Exception> onError = null,
+		Action onCompleted = null
+	) : base(onNext, onError, onCompleted) { }
 }
diff --git a/src/Elastic.Transport/Diagnostics/TcpStats.cs b/src/Elastic.Transport/Diagnostics/TcpStats.cs
index 9aa06ea..47f4c8f 100644
--- a/src/Elastic.Transport/Diagnostics/TcpStats.cs
+++ b/src/Elastic.Transport/Diagnostics/TcpStats.cs
@@ -7,56 +7,55 @@
 using System.Collections.ObjectModel;
 using System.Net.NetworkInformation;
 
-namespace Elastic.Transport.Diagnostics
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary>
+/// Gets statistics about TCP connections
+/// </summary>
+internal static class TcpStats
 {
+	private static readonly int StateLength = Enum.GetNames(typeof(TcpState)).Length;
+
 	/// <summary>
-	/// Gets statistics about TCP connections
+	/// Gets the active TCP connections
 	/// </summary>
-	internal static class TcpStats
-	{
-		private static readonly int StateLength = Enum.GetNames(typeof(TcpState)).Length;
-
-		/// <summary>
-		/// Gets the active TCP connections
-		/// </summary>
-		/// <returns></returns>
-		public static TcpConnectionInformation[] GetActiveTcpConnections() =>
-			IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections();
+	/// <returns></returns>
+	public static TcpConnectionInformation[] GetActiveTcpConnections() =>
+		IPGlobalProperties.GetIPGlobalProperties().GetActiveTcpConnections();
 
-		/// <summary>
-		/// Gets the sum for each state of the active TCP connections
-		/// </summary>
-		public static ReadOnlyDictionary<TcpState, int> GetStates()
+	/// <summary>
+	/// Gets the sum for each state of the active TCP connections
+	/// </summary>
+	public static ReadOnlyDictionary<TcpState, int> GetStates()
+	{
+		var states = new Dictionary<TcpState, int>(StateLength);
+		var connections = GetActiveTcpConnections();
+		for (var index = 0; index < connections.Length; index++)
 		{
-			var states = new Dictionary<TcpState, int>(StateLength);
-			var connections = GetActiveTcpConnections();
-			for (var index = 0; index < connections.Length; index++)
-			{
-				var connection = connections[index];
-				if (states.TryGetValue(connection.State, out var count))
-					states[connection.State] = ++count;
-				else
-					states.Add(connection.State, 1);
-			}
-
-			return new ReadOnlyDictionary<TcpState, int>(states);
+			var connection = connections[index];
+			if (states.TryGetValue(connection.State, out var count))
+				states[connection.State] = ++count;
+			else
+				states.Add(connection.State, 1);
 		}
 
-		/// <summary>
-		/// Gets the TCP statistics for a given network interface component
-		/// </summary>
-		public static TcpStatistics GetTcpStatistics(NetworkInterfaceComponent version)
+		return new ReadOnlyDictionary<TcpState, int>(states);
+	}
+
+	/// <summary>
+	/// Gets the TCP statistics for a given network interface component
+	/// </summary>
+	public static TcpStatistics GetTcpStatistics(NetworkInterfaceComponent version)
+	{
+		var properties = IPGlobalProperties.GetIPGlobalProperties();
+		switch (version)
 		{
-			var properties = IPGlobalProperties.GetIPGlobalProperties();
-			switch (version)
-			{
-				case NetworkInterfaceComponent.IPv4:
-					return properties.GetTcpIPv4Statistics();
-				case NetworkInterfaceComponent.IPv6:
-					return properties.GetTcpIPv6Statistics();
-				default:
-					throw new ArgumentException("version");
-			}
+			case NetworkInterfaceComponent.IPv4:
+				return properties.GetTcpIPv4Statistics();
+			case NetworkInterfaceComponent.IPv6:
+				return properties.GetTcpIPv6Statistics();
+			default:
+				throw new ArgumentException("version");
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Diagnostics/ThreadpoolStats.cs b/src/Elastic.Transport/Diagnostics/ThreadpoolStats.cs
index 8d3551f..cb30b85 100644
--- a/src/Elastic.Transport/Diagnostics/ThreadpoolStats.cs
+++ b/src/Elastic.Transport/Diagnostics/ThreadpoolStats.cs
@@ -6,62 +6,61 @@
 using System.Collections.ObjectModel;
 using System.Threading;
 
-namespace Elastic.Transport.Diagnostics
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary> Retrieves statistics for thread pools </summary>
+public static class ThreadPoolStats
 {
-	/// <summary> Retrieves statistics for thread pools </summary>
-	public static class ThreadPoolStats
-	{
-		private static readonly string WorkerThreads = "Worker";
-		private static readonly string CompletionPortThreads = "IOCP";
+	private static readonly string WorkerThreads = "Worker";
+	private static readonly string CompletionPortThreads = "IOCP";
 
-		/// <summary> Retrieve thread pool statistics </summary>
-		public static ReadOnlyDictionary<string, ThreadPoolStatistics> GetStats()
-		{
-			var dictionary = new Dictionary<string, ThreadPoolStatistics>(2);
-			ThreadPool.GetMaxThreads(out var maxWorkerThreads, out var maxIoThreads);
-			ThreadPool.GetAvailableThreads(out var freeWorkerThreads, out var freeIoThreads);
-			ThreadPool.GetMinThreads(out var minWorkerThreads, out var minIoThreads);
-			var busyIoThreads = maxIoThreads - freeIoThreads;
-			var busyWorkerThreads = maxWorkerThreads - freeWorkerThreads;
+	/// <summary> Retrieve thread pool statistics </summary>
+	public static ReadOnlyDictionary<string, ThreadPoolStatistics> GetStats()
+	{
+		var dictionary = new Dictionary<string, ThreadPoolStatistics>(2);
+		ThreadPool.GetMaxThreads(out var maxWorkerThreads, out var maxIoThreads);
+		ThreadPool.GetAvailableThreads(out var freeWorkerThreads, out var freeIoThreads);
+		ThreadPool.GetMinThreads(out var minWorkerThreads, out var minIoThreads);
+		var busyIoThreads = maxIoThreads - freeIoThreads;
+		var busyWorkerThreads = maxWorkerThreads - freeWorkerThreads;
 
-			dictionary.Add(WorkerThreads, new ThreadPoolStatistics(minWorkerThreads, maxWorkerThreads, busyWorkerThreads, freeWorkerThreads));
-			dictionary.Add(CompletionPortThreads, new ThreadPoolStatistics(minIoThreads, maxIoThreads, busyIoThreads, freeIoThreads));
-			return new ReadOnlyDictionary<string, ThreadPoolStatistics>(dictionary);
-		}
+		dictionary.Add(WorkerThreads, new ThreadPoolStatistics(minWorkerThreads, maxWorkerThreads, busyWorkerThreads, freeWorkerThreads));
+		dictionary.Add(CompletionPortThreads, new ThreadPoolStatistics(minIoThreads, maxIoThreads, busyIoThreads, freeIoThreads));
+		return new ReadOnlyDictionary<string, ThreadPoolStatistics>(dictionary);
 	}
+}
 
-	/// <summary> Statistics for a thread pool </summary>
-	public class ThreadPoolStatistics
+/// <summary> Statistics for a thread pool </summary>
+public class ThreadPoolStatistics
+{
+	/// <inheritdoc cref="ThreadPoolStatistics"/>>
+	public ThreadPoolStatistics(int min, int max, int busy, int free)
 	{
-		/// <inheritdoc cref="ThreadPoolStatistics"/>>
-		public ThreadPoolStatistics(int min, int max, int busy, int free)
-		{
-			Min = min;
-			Max = max;
-			Busy = busy;
-			Free = free;
-		}
+		Min = min;
+		Max = max;
+		Busy = busy;
+		Free = free;
+	}
 
-		/// <summary>The difference between the maximum number of thread pool threads returned by
-		/// <see cref="Max"/>, and the number currently free.
-		/// </summary>
-		public int Busy { get; }
+	/// <summary>The difference between the maximum number of thread pool threads returned by
+	/// <see cref="Max"/>, and the number currently free.
+	/// </summary>
+	public int Busy { get; }
 
-		/// <summary>The difference between the maximum number of thread pool threads returned by
-		/// <see cref="Max"/>, and the number currently active.
-		/// </summary>
-		public int Free { get; }
+	/// <summary>The difference between the maximum number of thread pool threads returned by
+	/// <see cref="Max"/>, and the number currently active.
+	/// </summary>
+	public int Free { get; }
 
-		/// <summary>
-		/// The number of requests to the thread pool that can be active concurrently. All requests above that number remain queued until
-		/// thread pool threads become available.
-		/// </summary>
-		public int Max { get; }
+	/// <summary>
+	/// The number of requests to the thread pool that can be active concurrently. All requests above that number remain queued until
+	/// thread pool threads become available.
+	/// </summary>
+	public int Max { get; }
 
-		/// <summary>
-		/// The minimum number of threads the thread pool creates on demand, as new requests are made, before switching to an algorithm for
-		/// managing thread creation and destruction.
-		/// </summary>
-		public int Min { get; }
-	}
+	/// <summary>
+	/// The minimum number of threads the thread pool creates on demand, as new requests are made, before switching to an algorithm for
+	/// managing thread creation and destruction.
+	/// </summary>
+	public int Min { get; }
 }
diff --git a/src/Elastic.Transport/Diagnostics/TypedDiagnosticObserver.cs b/src/Elastic.Transport/Diagnostics/TypedDiagnosticObserver.cs
index bfb2da1..b7a547e 100644
--- a/src/Elastic.Transport/Diagnostics/TypedDiagnosticObserver.cs
+++ b/src/Elastic.Transport/Diagnostics/TypedDiagnosticObserver.cs
@@ -6,80 +6,79 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 
-namespace Elastic.Transport.Diagnostics
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary>
+/// Provides a base implementation of <see cref="IObserver{T}"/> that makes it easier to consume
+/// the <see cref="DiagnosticSource"/>'s exposed in this library
+/// </summary>
+public abstract class TypedDiagnosticObserver<TOnNext> : IObserver<KeyValuePair<string, object>>
 {
-	/// <summary>
-	/// Provides a base implementation of <see cref="IObserver{T}"/> that makes it easier to consume
-	/// the <see cref="DiagnosticSource"/>'s exposed in this library
-	/// </summary>
-	public abstract class TypedDiagnosticObserver<TOnNext> : IObserver<KeyValuePair<string, object>>
+	private readonly Action<KeyValuePair<string, TOnNext>> _onNext;
+	private readonly Action<Exception> _onError;
+	private readonly Action _onCompleted;
+
+	/// <inheritdoc cref="TypedDiagnosticObserver{TOnNext}"/>
+	protected TypedDiagnosticObserver(
+		Action<KeyValuePair<string, TOnNext>> onNext,
+		Action<Exception> onError = null,
+		Action onCompleted = null
+	)
 	{
-		private readonly Action<KeyValuePair<string, TOnNext>> _onNext;
-		private readonly Action<Exception> _onError;
-		private readonly Action _onCompleted;
-
-		/// <inheritdoc cref="TypedDiagnosticObserver{TOnNext}"/>
-		protected TypedDiagnosticObserver(
-			Action<KeyValuePair<string, TOnNext>> onNext,
-			Action<Exception> onError = null,
-			Action onCompleted = null
-		)
-		{
-			_onNext= onNext;
-			_onError = onError;
-			_onCompleted = onCompleted;
-		}
-
-		void IObserver<KeyValuePair<string, object>>.OnCompleted() => _onCompleted?.Invoke();
-
-		void IObserver<KeyValuePair<string, object>>.OnError(Exception error) => _onError?.Invoke(error);
-
-		void IObserver<KeyValuePair<string, object>>.OnNext(KeyValuePair<string, object> value)
-		{
-			if (value.Value is TOnNext next) _onNext?.Invoke(new KeyValuePair<string, TOnNext>(value.Key, next));
-			else if (value.Value == null) _onNext?.Invoke(new KeyValuePair<string, TOnNext>(value.Key, default));
-
-			else throw new Exception($"{value.Key} received unexpected type {value.Value.GetType()}");
-
-		}
+		_onNext= onNext;
+		_onError = onError;
+		_onCompleted = onCompleted;
 	}
 
+	void IObserver<KeyValuePair<string, object>>.OnCompleted() => _onCompleted?.Invoke();
+
+	void IObserver<KeyValuePair<string, object>>.OnError(Exception error) => _onError?.Invoke(error);
+
+	void IObserver<KeyValuePair<string, object>>.OnNext(KeyValuePair<string, object> value)
+	{
+		if (value.Value is TOnNext next) _onNext?.Invoke(new KeyValuePair<string, TOnNext>(value.Key, next));
+		else if (value.Value == null) _onNext?.Invoke(new KeyValuePair<string, TOnNext>(value.Key, default));
+
+		else throw new Exception($"{value.Key} received unexpected type {value.Value.GetType()}");
+
+	}
+}
+
+/// <inheritdoc cref="TypedDiagnosticObserver{TOnNext}"/>
+public abstract class TypedDiagnosticObserver<TOnNextStart, TOnNextEnd> : IObserver<KeyValuePair<string, object>>
+{
+	private readonly Action<KeyValuePair<string, TOnNextStart>> _onNextStart;
+	private readonly Action<KeyValuePair<string, TOnNextEnd>> _onNextEnd;
+	private readonly Action<Exception> _onError;
+	private readonly Action _onCompleted;
+
 	/// <inheritdoc cref="TypedDiagnosticObserver{TOnNext}"/>
-	public abstract class TypedDiagnosticObserver<TOnNextStart, TOnNextEnd> : IObserver<KeyValuePair<string, object>>
+	protected TypedDiagnosticObserver(
+		Action<KeyValuePair<string, TOnNextStart>> onNextStart,
+		Action<KeyValuePair<string, TOnNextEnd>> onNextEnd,
+		Action<Exception> onError = null,
+		Action onCompleted = null
+	)
+	{
+		_onNextStart = onNextStart;
+		_onNextEnd = onNextEnd;
+		_onError = onError;
+		_onCompleted = onCompleted;
+	}
+
+	void IObserver<KeyValuePair<string, object>>.OnCompleted() => _onCompleted?.Invoke();
+
+	void IObserver<KeyValuePair<string, object>>.OnError(Exception error) => _onError?.Invoke(error);
+
+	void IObserver<KeyValuePair<string, object>>.OnNext(KeyValuePair<string, object> value)
 	{
-		private readonly Action<KeyValuePair<string, TOnNextStart>> _onNextStart;
-		private readonly Action<KeyValuePair<string, TOnNextEnd>> _onNextEnd;
-		private readonly Action<Exception> _onError;
-		private readonly Action _onCompleted;
-
-		/// <inheritdoc cref="TypedDiagnosticObserver{TOnNext}"/>
-		protected TypedDiagnosticObserver(
-			Action<KeyValuePair<string, TOnNextStart>> onNextStart,
-			Action<KeyValuePair<string, TOnNextEnd>> onNextEnd,
-			Action<Exception> onError = null,
-			Action onCompleted = null
-		)
-		{
-			_onNextStart = onNextStart;
-			_onNextEnd = onNextEnd;
-			_onError = onError;
-			_onCompleted = onCompleted;
-		}
-
-		void IObserver<KeyValuePair<string, object>>.OnCompleted() => _onCompleted?.Invoke();
-
-		void IObserver<KeyValuePair<string, object>>.OnError(Exception error) => _onError?.Invoke(error);
-
-		void IObserver<KeyValuePair<string, object>>.OnNext(KeyValuePair<string, object> value)
-		{
-			if (value.Value is TOnNextStart nextStart) _onNextStart?.Invoke(new KeyValuePair<string, TOnNextStart>(value.Key, nextStart));
-			else if (value.Key.EndsWith(".Start") && value.Value is null) _onNextStart?.Invoke(new KeyValuePair<string, TOnNextStart>(value.Key, default));
-
-			else if (value.Value is TOnNextEnd nextEnd) _onNextEnd?.Invoke(new KeyValuePair<string, TOnNextEnd>(value.Key, nextEnd));
-			else if (value.Key.EndsWith(".Stop") && value.Value is null) _onNextEnd?.Invoke(new KeyValuePair<string, TOnNextEnd>(value.Key, default));
-
-			else throw new Exception($"{value.Key} received unexpected type {value.Value.GetType()}");
-
-		}
+		if (value.Value is TOnNextStart nextStart) _onNextStart?.Invoke(new KeyValuePair<string, TOnNextStart>(value.Key, nextStart));
+		else if (value.Key.EndsWith(".Start") && value.Value is null) _onNextStart?.Invoke(new KeyValuePair<string, TOnNextStart>(value.Key, default));
+
+		else if (value.Value is TOnNextEnd nextEnd) _onNextEnd?.Invoke(new KeyValuePair<string, TOnNextEnd>(value.Key, nextEnd));
+		else if (value.Key.EndsWith(".Stop") && value.Value is null) _onNextEnd?.Invoke(new KeyValuePair<string, TOnNextEnd>(value.Key, default));
+
+		else throw new Exception($"{value.Key} received unexpected type {value.Value.GetType()}");
+
 	}
 }
diff --git a/src/Elastic.Transport/Elastic.Transport.csproj b/src/Elastic.Transport/Elastic.Transport.csproj
index 905c4ad..bfb0c44 100644
--- a/src/Elastic.Transport/Elastic.Transport.csproj
+++ b/src/Elastic.Transport/Elastic.Transport.csproj
@@ -18,6 +18,11 @@
     <TargetFrameworks>netstandard2.0;netstandard2.1;net461;net5.0;net6.0</TargetFrameworks>
   </PropertyGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="Elastic.Transport.VirtualizedCluster" Key="$(ExposedPublicKey)" />
+    <InternalsVisibleTo Include="Elastic.Transport.Tests" Key="$(ExposedPublicKey)" />
+  </ItemGroup>
+    
   <ItemGroup>
     <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
     <PackageReference Include="System.Buffers" Version="4.5.1" />
diff --git a/src/Elastic.Transport/Exceptions/TransportException.cs b/src/Elastic.Transport/Exceptions/TransportException.cs
index b26ad63..c8b1b8e 100644
--- a/src/Elastic.Transport/Exceptions/TransportException.cs
+++ b/src/Elastic.Transport/Exceptions/TransportException.cs
@@ -8,114 +8,112 @@
 using System.Text;
 using Elastic.Transport.Diagnostics.Auditing;
 using Elastic.Transport.Extensions;
-using static Elastic.Transport.ResponseStatics;
+using static Elastic.Transport.Diagnostics.ResponseStatics;
 
-namespace Elastic.Transport
-{
+namespace Elastic.Transport;
 
-	/// <summary>
-	/// Exceptions that occur <see cref="ITransport.Request{TResponse}"/> are wrapped inside
-	/// this exception. This is done to not lose valuable diagnostic information.
-	///
-	/// <para>
-	/// When <see cref="ITransportConfiguration.ThrowExceptions"/> is set these exceptions are rethrown and need
-	/// to be caught
-	/// </para>
-	/// </summary>
-	public class TransportException : Exception
-	{
-		/// <inheritdoc cref="TransportException"/>
-		public TransportException(string message) : base(message) => FailureReason = PipelineFailure.Unexpected;
+/// <summary>
+/// Exceptions that occur <see cref="HttpTransport.Request{TResponse}"/> are wrapped inside
+/// this exception. This is done to not lose valuable diagnostic information.
+///
+/// <para>
+/// When <see cref="ITransportConfiguration.ThrowExceptions"/> is set these exceptions are rethrown and need
+/// to be caught
+/// </para>
+/// </summary>
+public class TransportException : Exception
+{
+	/// <inheritdoc cref="TransportException"/>
+	public TransportException(string message) : base(message) => FailureReason = PipelineFailure.Unexpected;
 
-		/// <inheritdoc cref="TransportException"/>
-		public TransportException(PipelineFailure failure, string message, Exception innerException)
-			: base(message, innerException) => FailureReason = failure;
+	/// <inheritdoc cref="TransportException"/>
+	public TransportException(PipelineFailure failure, string message, Exception innerException)
+		: base(message, innerException) => FailureReason = failure;
 
-		/// <inheritdoc cref="TransportException"/>
-		public TransportException(PipelineFailure failure, string message, IApiCallDetails apiCall)
-			: this(message)
-		{
-			Response = apiCall;
-			FailureReason = failure;
-			AuditTrail = apiCall?.AuditTrail;
-		}
+	/// <inheritdoc cref="TransportException"/>
+	public TransportException(PipelineFailure failure, string message, TransportResponse response)
+		: this(message)
+	{
+		ApiCallDetails = response.ApiCallDetails;
+		FailureReason = failure;
+		AuditTrail = response.ApiCallDetails?.AuditTrail;
+	}
 
-		/// <summary>
-		/// The audit trail keeping track of what happened during the invocation of
-		/// <see cref="ITransport.Request{TResponse}"/> up until the moment of this exception
-		/// </summary>
-		public IEnumerable<Audit> AuditTrail { get; internal set; }
+	/// <summary>
+	/// The audit trail keeping track of what happened during the invocation of
+	/// <see cref="HttpTransport.Request{TResponse}"/> up until the moment of this exception
+	/// </summary>
+	public IEnumerable<Audit> AuditTrail { get; internal set; }
 
-		/// <summary>
-		/// The reason this exception occurred was one of the well defined exit points as modelled by
-		/// <see cref="PipelineFailure"/>
-		/// </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		public PipelineFailure? FailureReason { get; }
+	/// <summary>
+	/// The reason this exception occurred was one of the well defined exit points as modelled by
+	/// <see cref="PipelineFailure"/>
+	/// </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	public PipelineFailure? FailureReason { get; }
 
-		/// <summary> Information about the request that triggered this exception </summary>
-		public RequestData Request { get; internal set; }
+	/// <summary> Information about the request that triggered this exception </summary>
+	public RequestData Request { get; internal set; }
 
-		/// <summary> The response if available that triggered the exception </summary>
-		public IApiCallDetails Response { get; internal set; }
+	/// <summary> The response if available that triggered the exception </summary>
+	public ApiCallDetails ApiCallDetails { get; internal set; }
 
-		/// <summary>
-		/// A self describing human readable string explaining why this exception was thrown.
-		/// <para>Useful in logging and diagnosing + reporting issues!</para>
-		/// </summary>
-		// ReSharper disable once UnusedMember.Global
-		public string DebugInformation
+	/// <summary>
+	/// A self describing human readable string explaining why this exception was thrown.
+	/// <para>Useful in logging and diagnosing + reporting issues!</para>
+	/// </summary>
+	// ReSharper disable once UnusedMember.Global
+	public string DebugInformation
+	{
+		get
 		{
-			get
-			{
-				var sb = new StringBuilder();
-				var failureReason = FailureReason.GetStringValue();
-				if (FailureReason == PipelineFailure.Unexpected && AuditTrail.HasAny(out var auditTrail))
-					failureReason = "Unrecoverable/Unexpected " + auditTrail.Last().Event.GetStringValue();
+			var sb = new StringBuilder();
+			var failureReason = FailureReason.GetStringValue();
+			if (FailureReason == PipelineFailure.Unexpected && AuditTrail.HasAny(out var auditTrail))
+				failureReason = "Unrecoverable/Unexpected " + auditTrail.Last().Event.GetStringValue();
 
-				sb.Append("# FailureReason: ")
-					.Append(failureReason)
-					.Append(" while attempting ");
+			sb.Append("# FailureReason: ")
+				.Append(failureReason)
+				.Append(" while attempting ");
 
-				if (Request != null)
-				{
-					sb.Append(Request.Method.GetStringValue()).Append(" on ");
-					if (Request.Uri != null)
-						sb.AppendLine(Request.Uri.ToString());
-					else
-					{
-						sb.Append(Request.PathAndQuery)
-							.AppendLine(" on an empty node, likely a node predicate on ConnectionSettings not matching ANY nodes");
-					}
-				}
-				else if (Response != null)
-				{
-					sb.Append(Response.HttpMethod.GetStringValue())
-						.Append(" on ")
-						.AppendLine(Response.Uri.ToString());
-				}
-				else
-					sb.AppendLine("a request");
-
-				if (Response != null)
-					DebugInformationBuilder(Response, sb);
+			if (Request != null)
+			{
+				sb.Append(Request.Method.GetStringValue()).Append(" on ");
+				if (Request.Uri != null)
+					sb.AppendLine(Request.Uri.ToString());
 				else
 				{
-					DebugAuditTrail(AuditTrail, sb);
-					DebugAuditTrailExceptions(AuditTrail, sb);
+					sb.Append(Request.PathAndQuery)
+						.AppendLine(" on an empty node, likely a node predicate on ConnectionSettings not matching ANY nodes");
 				}
+			}
+			else if (ApiCallDetails != null)
+			{
+				sb.Append(ApiCallDetails.HttpMethod.GetStringValue())
+					.Append(" on ")
+					.AppendLine(ApiCallDetails.Uri.ToString());
+			}
+			else
+				sb.AppendLine("a request");
 
-				if (InnerException != null)
-				{
-					sb.Append("# Inner Exception: ")
-						.AppendLine(InnerException.Message)
-						.AppendLine(InnerException.ToString());
-				}
+			if (ApiCallDetails != null)
+				DebugInformationBuilder(ApiCallDetails, sb);
+			else
+			{
+				DebugAuditTrail(AuditTrail, sb);
+				DebugAuditTrailExceptions(AuditTrail, sb);
+			}
 
-				sb.AppendLine("# Exception:")
-					.AppendLine(ToString());
-				return sb.ToString();
+			if (InnerException != null)
+			{
+				sb.Append("# Inner Exception: ")
+					.AppendLine(InnerException.Message)
+					.AppendLine(InnerException.ToString());
 			}
+
+			sb.AppendLine("# Exception:")
+				.AppendLine(ToString());
+			return sb.ToString();
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Exceptions/UnexpectedTransportException.cs b/src/Elastic.Transport/Exceptions/UnexpectedTransportException.cs
index b6067c1..f6c1c36 100644
--- a/src/Elastic.Transport/Exceptions/UnexpectedTransportException.cs
+++ b/src/Elastic.Transport/Exceptions/UnexpectedTransportException.cs
@@ -6,26 +6,22 @@
 using System.Collections.Generic;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// An exception occured that was not the result of one the well defined exit points as modelled by
+/// <see cref="PipelineFailure"/>. This exception will always bubble out.
+/// </summary>
+public class UnexpectedTransportException : TransportException
 {
+	/// <inheritdoc cref="UnexpectedTransportException"/>
+	public UnexpectedTransportException(Exception killerException, IReadOnlyCollection<PipelineException> seenExceptions)
+		: base(PipelineFailure.Unexpected, killerException?.Message ?? "An unexpected exception occurred.", killerException) =>
+		SeenExceptions = seenExceptions ?? EmptyReadOnly<PipelineException>.Collection;
 
 	/// <summary>
-	/// An exception occured that was not the result of one the well defined exit points as modelled by
-	/// <see cref="PipelineFailure"/>. This exception will always bubble out.
+	/// Seen Exceptions that we try to failover on before this <see cref="UnexpectedTransportException"/> was thrown.
 	/// </summary>
-	public class UnexpectedTransportException : TransportException
-	{
-		/// <inheritdoc cref="UnexpectedTransportException"/>
-		public UnexpectedTransportException(Exception killerException, IReadOnlyCollection<PipelineException> seenExceptions)
-			: base(PipelineFailure.Unexpected, killerException?.Message ?? "An unexpected exception occurred.", killerException) =>
-			SeenExceptions = seenExceptions ?? EmptyReadOnly<PipelineException>.Collection;
-
-		/// <summary>
-		/// Seen Exceptions that we try to failover on before this <see cref="UnexpectedTransportException"/> was thrown.
-		/// </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		public IReadOnlyCollection<PipelineException> SeenExceptions { get; }
-	}
-
-
+	// ReSharper disable once MemberCanBePrivate.Global
+	public IReadOnlyCollection<PipelineException> SeenExceptions { get; }
 }
diff --git a/src/Elastic.Transport/Extensions/EmptyReadonly.cs b/src/Elastic.Transport/Extensions/EmptyReadonly.cs
index dd93aca..1695d3b 100644
--- a/src/Elastic.Transport/Extensions/EmptyReadonly.cs
+++ b/src/Elastic.Transport/Extensions/EmptyReadonly.cs
@@ -6,27 +6,26 @@
 using System.Collections.ObjectModel;
 using System.Linq;
 
-namespace Elastic.Transport.Extensions
-{
-	internal static class EmptyReadOnlyExtensions
-	{
-		public static IReadOnlyCollection<T> ToReadOnlyCollection<T>(this IEnumerable<T> enumerable) =>
-			enumerable == null ? EmptyReadOnly<T>.Collection : new ReadOnlyCollection<T>(enumerable.ToList());
+namespace Elastic.Transport.Extensions;
 
-		public static IReadOnlyCollection<T> ToReadOnlyCollection<T>(this IList<T> enumerable) =>
-			enumerable == null || enumerable.Count == 0 ? EmptyReadOnly<T>.Collection : new ReadOnlyCollection<T>(enumerable);
-	}
+internal static class EmptyReadOnlyExtensions
+{
+	public static IReadOnlyCollection<T> ToReadOnlyCollection<T>(this IEnumerable<T> enumerable) =>
+		enumerable == null ? EmptyReadOnly<T>.Collection : new ReadOnlyCollection<T>(enumerable.ToList());
 
+	public static IReadOnlyCollection<T> ToReadOnlyCollection<T>(this IList<T> enumerable) =>
+		enumerable == null || enumerable.Count == 0 ? EmptyReadOnly<T>.Collection : new ReadOnlyCollection<T>(enumerable);
+}
 
-	internal static class EmptyReadOnly<TElement>
-	{
-		public static readonly IReadOnlyCollection<TElement> Collection = new ReadOnlyCollection<TElement>(new TElement[0]);
-		public static readonly IReadOnlyList<TElement> List = new List<TElement>();
-	}
 
-	internal static class EmptyReadOnly<TKey, TValue>
-	{
-		public static readonly IReadOnlyDictionary<TKey, TValue> Dictionary = new ReadOnlyDictionary<TKey, TValue>(new Dictionary<TKey, TValue>(0));
-	}
+internal static class EmptyReadOnly<TElement>
+{
+	public static readonly IReadOnlyCollection<TElement> Collection = new ReadOnlyCollection<TElement>(new TElement[0]);
+	public static readonly IReadOnlyList<TElement> List = new List<TElement>();
+}
 
+internal static class EmptyReadOnly<TKey, TValue>
+{
+	public static readonly IReadOnlyDictionary<TKey, TValue> Dictionary = new ReadOnlyDictionary<TKey, TValue>(new Dictionary<TKey, TValue>(0));
 }
+
diff --git a/src/Elastic.Transport/Extensions/EnumExtensions.cs b/src/Elastic.Transport/Extensions/EnumExtensions.cs
index 2960e82..2c42aed 100644
--- a/src/Elastic.Transport/Extensions/EnumExtensions.cs
+++ b/src/Elastic.Transport/Extensions/EnumExtensions.cs
@@ -7,67 +7,66 @@
 using System.Collections.Generic;
 using System.Runtime.Serialization;
 
-namespace Elastic.Transport.Extensions
+namespace Elastic.Transport.Extensions;
+
+/// <summary>
+/// Cached to string extension method for enums. This is public because we expect most clients to need this.
+/// <para>This takes <see cref="EnumMemberAttribute"/> into account</para>
+/// </summary>
+public static class EnumExtensions
 {
-	/// <summary>
-	/// Cached to string extension method for enums. This is public because we expect most clients to need this.
-	/// <para>This takes <see cref="EnumMemberAttribute"/> into account</para>
-	/// </summary>
-	public static class EnumExtensions
+	internal static string GetStringValue(this HttpMethod enumValue)
 	{
-		internal static string GetStringValue(this HttpMethod enumValue)
+		switch (enumValue)
 		{
-			switch (enumValue)
-			{
-				case HttpMethod.GET: return "GET";
-				case HttpMethod.POST: return "POST";
-				case HttpMethod.PUT: return "PUT";
-				case HttpMethod.DELETE: return "DELETE";
-				case HttpMethod.HEAD: return "HEAD";
-				default:
-					throw new ArgumentOutOfRangeException(nameof(enumValue), enumValue, null);
-			}
+			case HttpMethod.GET: return "GET";
+			case HttpMethod.POST: return "POST";
+			case HttpMethod.PUT: return "PUT";
+			case HttpMethod.DELETE: return "DELETE";
+			case HttpMethod.HEAD: return "HEAD";
+			default:
+				throw new ArgumentOutOfRangeException(nameof(enumValue), enumValue, null);
 		}
+	}
 
-		private static readonly ConcurrentDictionary<Type, Func<Enum, string>> EnumStringResolvers = new ConcurrentDictionary<Type, Func<Enum, string>>();
+	private static readonly ConcurrentDictionary<Type, Func<Enum, string>> EnumStringResolvers = new ConcurrentDictionary<Type, Func<Enum, string>>();
 
-		/// <summary>
-		/// Returns the string representation of the enum taking into account <see cref="EnumMemberAttribute"/>
-		/// </summary>
-		public static string GetStringValue(this Enum e)
+	/// <summary>
+	/// Returns the string representation of the enum taking into account <see cref="EnumMemberAttribute"/>
+	/// </summary>
+	public static string GetStringValue(this Enum e)
+	{
+		var type = e.GetType();
+		var resolver = EnumStringResolvers.GetOrAdd(type, t => GetEnumStringResolver(t));
+		return resolver(e);
+	}
+
+	private static Func<Enum, string> GetEnumStringResolver(Type type)
+	{
+		var values = Enum.GetValues(type);
+		var dictionary = new Dictionary<Enum, string>(values.Length);
+		for (var index = 0; index < values.Length; index++)
 		{
-			var type = e.GetType();
-			var resolver = EnumStringResolvers.GetOrAdd(type, t => GetEnumStringResolver(t));
-			return resolver(e);
+			var value = values.GetValue(index);
+			var info = type.GetField(value.ToString());
+			var da = (EnumMemberAttribute[])info.GetCustomAttributes(typeof(EnumMemberAttribute), false);
+			var stringValue = da.Length > 0 ? da[0].Value : Enum.GetName(type, value);
+			dictionary.Add((Enum)value, stringValue);
 		}
 
-		private static Func<Enum, string> GetEnumStringResolver(Type type)
+		var isFlag = type.GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
+		return e =>
 		{
-			var values = Enum.GetValues(type);
-			var dictionary = new Dictionary<Enum, string>(values.Length);
-			for (var index = 0; index < values.Length; index++)
-			{
-				var value = values.GetValue(index);
-				var info = type.GetField(value.ToString());
-				var da = (EnumMemberAttribute[])info.GetCustomAttributes(typeof(EnumMemberAttribute), false);
-				var stringValue = da.Length > 0 ? da[0].Value : Enum.GetName(type, value);
-				dictionary.Add((Enum)value, stringValue);
-			}
+			if (!isFlag) return dictionary[e];
 
-			var isFlag = type.GetCustomAttributes(typeof(FlagsAttribute), false).Length > 0;
-			return e =>
+			var list = new List<string>();
+			foreach (var kv in dictionary)
 			{
-				if (!isFlag) return dictionary[e];
-
-				var list = new List<string>();
-				foreach (var kv in dictionary)
-				{
-					if (e.HasFlag(kv.Key))
-						list.Add(kv.Value);
-				}
+				if (e.HasFlag(kv.Key))
+					list.Add(kv.Value);
+			}
 
-				return string.Join(",", list);
-			};
-		}
+			return string.Join(",", list);
+		};
 	}
 }
diff --git a/src/Elastic.Transport/Extensions/Extensions.cs b/src/Elastic.Transport/Extensions/Extensions.cs
index 8beffc6..cbaf0e4 100644
--- a/src/Elastic.Transport/Extensions/Extensions.cs
+++ b/src/Elastic.Transport/Extensions/Extensions.cs
@@ -9,105 +9,104 @@
 using System.Linq;
 using System.Text;
 
-namespace Elastic.Transport.Extensions
+namespace Elastic.Transport.Extensions;
+
+internal static class Extensions
 {
-	internal static class Extensions
+	[Obsolete("Please use the overload placing the enumerated array as out")]
+	internal static bool HasAny<T>(this ICollection<T> list) => list != null && list.Any();
+
+	internal static bool HasAny<T>(this IEnumerable<T> list, out T[] enumerated)
 	{
-		[Obsolete("Please use the overload placing the enumerated array as out")]
-		internal static bool HasAny<T>(this ICollection<T> list) => list != null && list.Any();
+		enumerated = list == null ? null : (list as T[] ?? list.ToArray());
+		return enumerated != null && enumerated.Length > 0;
+	}
 
-		internal static bool HasAny<T>(this IEnumerable<T> list, out T[] enumerated)
-		{
-			enumerated = list == null ? null : (list as T[] ?? list.ToArray());
-			return enumerated != null && enumerated.Length > 0;
-		}
+	internal static IEnumerable<T> DistinctByCustom<T, TKey>(this IEnumerable<T> items, Func<T, TKey> property) =>
+		items.GroupBy(property).Select(x => x.First());
 
-		internal static IEnumerable<T> DistinctByCustom<T, TKey>(this IEnumerable<T> items, Func<T, TKey> property) =>
-			items.GroupBy(property).Select(x => x.First());
+	internal static void ThrowIfEmpty<T>(this IEnumerable<T> @object, string parameterName)
+	{
+		var enumerated = @object == null ? null : (@object as T[] ?? @object.ToArray());
+		enumerated.ThrowIfNull(parameterName);
+		if (!enumerated!.Any())
+			throw new ArgumentException("Argument can not be an empty collection", parameterName);
+	}
+	internal static void ThrowIfNull<T>(this T value, string name) where T : class
+	{
+		if (value == null)
+			throw new ArgumentNullException(name);
+	}
 
-		internal static void ThrowIfEmpty<T>(this IEnumerable<T> @object, string parameterName)
-		{
-			var enumerated = @object == null ? null : (@object as T[] ?? @object.ToArray());
-			enumerated.ThrowIfNull(parameterName);
-			if (!enumerated!.Any())
-				throw new ArgumentException("Argument can not be an empty collection", parameterName);
-		}
-		internal static void ThrowIfNull<T>(this T value, string name) where T : class
-		{
-			if (value == null)
-				throw new ArgumentNullException(name);
-		}
+	internal static bool IsNullOrEmpty(this string value) => string.IsNullOrEmpty(value);
 
-		internal static bool IsNullOrEmpty(this string value) => string.IsNullOrEmpty(value);
+	internal static string Utf8String(this byte[] bytes) => bytes == null ? null : Encoding.UTF8.GetString(bytes, 0, bytes.Length);
 
-		internal static string Utf8String(this byte[] bytes) => bytes == null ? null : Encoding.UTF8.GetString(bytes, 0, bytes.Length);
+	internal static string Utf8String(this MemoryStream ms)
+	{
+		if (ms is null)
+			return null;
 
-		internal static string Utf8String(this MemoryStream ms)
-		{
-			if (ms is null)
-				return null;
+		if (!ms.TryGetBuffer(out var buffer) || buffer.Array is null)
+			return Encoding.UTF8.GetString(ms.ToArray());
 
-			if (!ms.TryGetBuffer(out var buffer) || buffer.Array is null)
-				return Encoding.UTF8.GetString(ms.ToArray());
+		return Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count);
+	}
 
-			return Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count);
-		}
+	internal static byte[] Utf8Bytes(this string s) => s.IsNullOrEmpty() ? null : Encoding.UTF8.GetBytes(s);
 
-		internal static byte[] Utf8Bytes(this string s) => s.IsNullOrEmpty() ? null : Encoding.UTF8.GetBytes(s);
+	private const long MillisecondsInAWeek = MillisecondsInADay * 7;
+	private const long MillisecondsInADay = MillisecondsInAnHour * 24;
+	private const long MillisecondsInAnHour = MillisecondsInAMinute * 60;
+	private const long MillisecondsInAMinute = MillisecondsInASecond * 60;
+	private const long MillisecondsInASecond = 1000;
 
-		private const long MillisecondsInAWeek = MillisecondsInADay * 7;
-		private const long MillisecondsInADay = MillisecondsInAnHour * 24;
-		private const long MillisecondsInAnHour = MillisecondsInAMinute * 60;
-		private const long MillisecondsInAMinute = MillisecondsInASecond * 60;
-		private const long MillisecondsInASecond = 1000;
+	internal static string ToTimeUnit(this TimeSpan timeSpan)
+	{
+		var ms = timeSpan.TotalMilliseconds;
+		string interval;
+		double factor;
 
-		internal static string ToTimeUnit(this TimeSpan timeSpan)
+		if (ms >= MillisecondsInAWeek)
 		{
-			var ms = timeSpan.TotalMilliseconds;
-			string interval;
-			double factor;
-
-			if (ms >= MillisecondsInAWeek)
-			{
-				factor = ms / MillisecondsInAWeek;
-				interval = "w";
-			}
-			else if (ms >= MillisecondsInADay)
-			{
-				factor = ms / MillisecondsInADay;
-				interval = "d";
-			}
-			else if (ms >= MillisecondsInAnHour)
-			{
-				factor = ms / MillisecondsInAnHour;
-				interval = "h";
-			}
-			else if (ms >= MillisecondsInAMinute)
-			{
-				factor = ms / MillisecondsInAMinute;
-				interval = "m";
-			}
-			else if (ms >= MillisecondsInASecond)
-			{
-				factor = ms / MillisecondsInASecond;
-				interval = "s";
-			}
-			else
-			{
-				factor = ms;
-				interval = "ms";
-			}
-
-			return factor.ToString("0.##", CultureInfo.InvariantCulture) + interval;
+			factor = ms / MillisecondsInAWeek;
+			interval = "w";
 		}
-
-		internal static Exception AsAggregateOrFirst(this IEnumerable<Exception> exceptions)
+		else if (ms >= MillisecondsInADay)
 		{
-			var es = exceptions as Exception[] ?? exceptions?.ToArray();
-			if (es == null || es.Length == 0) return null;
-
-			return es.Length == 1 ? es[0] : new AggregateException(es);
+			factor = ms / MillisecondsInADay;
+			interval = "d";
+		}
+		else if (ms >= MillisecondsInAnHour)
+		{
+			factor = ms / MillisecondsInAnHour;
+			interval = "h";
+		}
+		else if (ms >= MillisecondsInAMinute)
+		{
+			factor = ms / MillisecondsInAMinute;
+			interval = "m";
+		}
+		else if (ms >= MillisecondsInASecond)
+		{
+			factor = ms / MillisecondsInASecond;
+			interval = "s";
+		}
+		else
+		{
+			factor = ms;
+			interval = "ms";
 		}
 
+		return factor.ToString("0.##", CultureInfo.InvariantCulture) + interval;
+	}
+
+	internal static Exception AsAggregateOrFirst(this IEnumerable<Exception> exceptions)
+	{
+		var es = exceptions as Exception[] ?? exceptions?.ToArray();
+		if (es == null || es.Length == 0) return null;
+
+		return es.Length == 1 ? es[0] : new AggregateException(es);
 	}
+
 }
diff --git a/src/Elastic.Transport/Extensions/Fluent.cs b/src/Elastic.Transport/Extensions/Fluent.cs
index 95e3a10..7f86db8 100644
--- a/src/Elastic.Transport/Extensions/Fluent.cs
+++ b/src/Elastic.Transport/Extensions/Fluent.cs
@@ -4,15 +4,14 @@
 
 using System;
 
-namespace Elastic.Transport.Extensions
+namespace Elastic.Transport.Extensions;
+
+internal static class Fluent
 {
-	internal static class Fluent
+	internal static TDescriptor Assign<TDescriptor, TInterface, TValue>(TDescriptor self, TValue value, Action<TInterface, TValue> assign)
+		where TDescriptor : class, TInterface
 	{
-		internal static TDescriptor Assign<TDescriptor, TInterface, TValue>(TDescriptor self, TValue value, Action<TInterface, TValue> assign)
-			where TDescriptor : class, TInterface
-		{
-			assign(self, value);
-			return self;
-		}
+		assign(self, value);
+		return self;
 	}
 }
diff --git a/src/Elastic.Transport/Extensions/NameValueCollectionExtensions.cs b/src/Elastic.Transport/Extensions/NameValueCollectionExtensions.cs
index 1c40413..704fc52 100644
--- a/src/Elastic.Transport/Extensions/NameValueCollectionExtensions.cs
+++ b/src/Elastic.Transport/Extensions/NameValueCollectionExtensions.cs
@@ -9,82 +9,81 @@
 using System.Linq;
 using System.Text;
 
-namespace Elastic.Transport.Extensions
+namespace Elastic.Transport.Extensions;
+
+internal static class NameValueCollectionExtensions
 {
-	internal static class NameValueCollectionExtensions
+	private const int MaxCharsOnStack = 256; // 512 bytes
+
+	internal static string ToQueryString(this NameValueCollection nv)
 	{
-		private const int MaxCharsOnStack = 256; // 512 bytes
+		if (nv == null || nv.AllKeys.Length == 0) return string.Empty;
 
-		internal static string ToQueryString(this NameValueCollection nv)
+		var maxLength = 1 + nv.AllKeys.Length - 1; // account for '?', and any required '&' chars
+		foreach (var key in nv.AllKeys)
 		{
-			if (nv == null || nv.AllKeys.Length == 0) return string.Empty;
+			var bytes = Encoding.UTF8.GetByteCount(key) + Encoding.UTF8.GetByteCount(nv[key] ?? string.Empty);
+			var maxEncodedSize = bytes * 3; // worst case, assume all bytes are URL escaped to 3 chars
+			maxLength += 1 + maxEncodedSize; // '=' + encoded chars
+		}
 
-			var maxLength = 1 + nv.AllKeys.Length - 1; // account for '?', and any required '&' chars
-			foreach (var key in nv.AllKeys)
-			{
-				var bytes = Encoding.UTF8.GetByteCount(key) + Encoding.UTF8.GetByteCount(nv[key] ?? string.Empty);
-				var maxEncodedSize = bytes * 3; // worst case, assume all bytes are URL escaped to 3 chars
-				maxLength += 1 + maxEncodedSize; // '=' + encoded chars
-			}
+		// prefer stack allocated array for short lengths
+		// note: renting for larger lengths is slightly more efficient since no zeroing occurs
+		char[] rentedFromPool = null;
+		var buffer = maxLength > MaxCharsOnStack
+			? rentedFromPool = ArrayPool<char>.Shared.Rent(maxLength)
+			: stackalloc char[maxLength];
 
-			// prefer stack allocated array for short lengths
-			// note: renting for larger lengths is slightly more efficient since no zeroing occurs
-			char[] rentedFromPool = null;
-			var buffer = maxLength > MaxCharsOnStack
-				? rentedFromPool = ArrayPool<char>.Shared.Rent(maxLength)
-				: stackalloc char[maxLength];
+		try
+		{
+			var position = 0;
+			buffer[position++] = '?';
 
-			try
+			foreach (var key in nv.AllKeys)
 			{
-				var position = 0;
-				buffer[position++] = '?';
-
-				foreach (var key in nv.AllKeys)
-				{
-					if (position != 1)
-						buffer[position++] = '&';
-
-					var escapedKey = Uri.EscapeDataString(key);
-					escapedKey.AsSpan().CopyTo(buffer.Slice(position));
-					position += escapedKey.Length;
+				if (position != 1)
+					buffer[position++] = '&';
 
-					var value = nv[key];
+				var escapedKey = Uri.EscapeDataString(key);
+				escapedKey.AsSpan().CopyTo(buffer.Slice(position));
+				position += escapedKey.Length;
 
-					if (value.IsNullOrEmpty()) continue;
+				var value = nv[key];
 
-					buffer[position++] = '=';
-					var escapedValue = Uri.EscapeDataString(value);
-					escapedValue.AsSpan().CopyTo(buffer.Slice(position));
-					position += escapedValue.Length;
-				}
+				if (value.IsNullOrEmpty()) continue;
 
-				return buffer.Slice(0, position).ToString();
+				buffer[position++] = '=';
+				var escapedValue = Uri.EscapeDataString(value);
+				escapedValue.AsSpan().CopyTo(buffer.Slice(position));
+				position += escapedValue.Length;
 			}
-			finally
-			{
-				if (rentedFromPool != null)
-					ArrayPool<char>.Shared.Return(rentedFromPool, clearArray: false);
-			}
-		}
 
-		internal static void UpdateFromDictionary(this NameValueCollection queryString, Dictionary<string, object> queryStringUpdates, UrlFormatter provider)
+			return buffer.Slice(0, position).ToString();
+		}
+		finally
 		{
-			if (queryString == null || queryString.Count < 0) return;
-			if (queryStringUpdates == null || queryStringUpdates.Count < 0) return;
+			if (rentedFromPool != null)
+				ArrayPool<char>.Shared.Return(rentedFromPool, clearArray: false);
+		}
+	}
+
+	internal static void UpdateFromDictionary(this NameValueCollection queryString, Dictionary<string, object> queryStringUpdates, UrlFormatter provider)
+	{
+		if (queryString == null || queryString.Count < 0) return;
+		if (queryStringUpdates == null || queryStringUpdates.Count < 0) return;
 
-			foreach (var kv in queryStringUpdates.Where(kv => !kv.Key.IsNullOrEmpty()))
+		foreach (var kv in queryStringUpdates.Where(kv => !kv.Key.IsNullOrEmpty()))
+		{
+			if (kv.Value == null)
 			{
-				if (kv.Value == null)
-				{
-					queryString.Remove(kv.Key);
-					continue;
-				}
-				var resolved = provider.CreateString(kv.Value);
-				if (resolved != null)
-					queryString[kv.Key] = resolved;
-				else
-					queryString.Remove(kv.Key);
+				queryString.Remove(kv.Key);
+				continue;
 			}
+			var resolved = provider.CreateString(kv.Value);
+			if (resolved != null)
+				queryString[kv.Key] = resolved;
+			else
+				queryString.Remove(kv.Key);
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Extensions/StringExtensions.cs b/src/Elastic.Transport/Extensions/StringExtensions.cs
new file mode 100644
index 0000000..92a48b6
--- /dev/null
+++ b/src/Elastic.Transport/Extensions/StringExtensions.cs
@@ -0,0 +1,23 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+namespace Elastic.Transport;
+
+internal static class StringExtensions
+{
+	internal static string ToCamelCase(this string s)
+	{
+		if (string.IsNullOrEmpty(s))
+			return s;
+
+		if (!char.IsUpper(s[0]))
+			return s;
+
+		var camelCase = char.ToLowerInvariant(s[0]).ToString();
+		if (s.Length > 1)
+			camelCase += s.Substring(1);
+
+		return camelCase;
+	}
+}
diff --git a/src/Elastic.Transport/HttpTransport.cs b/src/Elastic.Transport/HttpTransport.cs
new file mode 100644
index 0000000..6707534
--- /dev/null
+++ b/src/Elastic.Transport/HttpTransport.cs
@@ -0,0 +1,46 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Elastic.Transport;
+
+/// <summary>
+/// Represents a transport you can call requests, it is recommended to implement <see cref="HttpTransport{TSettings}" />
+/// </summary>
+public abstract class HttpTransport
+{
+	/// <summary>
+	/// Perform a request into the products cluster using <see cref="RequestPipeline" />'s workflow.
+	/// </summary>
+	public abstract TResponse Request<TResponse>(
+		HttpMethod method,
+		string path,
+		PostData data = null,
+		RequestParameters requestParameters = null)
+		where TResponse : TransportResponse, new();
+
+	/// <inheritdoc cref="Request{TResponse}" />
+	public abstract Task<TResponse> RequestAsync<TResponse>(
+		HttpMethod method,
+		string path,
+		PostData data = null,
+		RequestParameters requestParameters = null,
+		CancellationToken cancellationToken = default)
+		where TResponse : TransportResponse, new();
+}
+
+/// <summary>
+/// Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
+/// different nodes
+/// </summary>
+public abstract class HttpTransport<TConfiguration> : HttpTransport
+	where TConfiguration : class, ITransportConfiguration
+{
+	/// <summary>
+	/// The <see cref="ITransportConfiguration" /> in use by this transport instance
+	/// </summary>
+	public abstract TConfiguration Settings { get; }
+}
diff --git a/src/Elastic.Transport/ITransport.cs b/src/Elastic.Transport/ITransport.cs
deleted file mode 100644
index 7d92335..0000000
--- a/src/Elastic.Transport/ITransport.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// Represents a transport you can call requests, it is recommended to implement <see cref="ITransport{TSettings}" />
-	/// </summary>
-	public interface ITransport
-	{
-		/// <summary>
-		/// Perform a request into the products cluster using <see cref="IRequestPipeline" />'s workflow.
-		/// </summary>
-		TResponse Request<TResponse>(
-			HttpMethod method,
-			string path,
-			PostData data = null,
-			IRequestParameters requestParameters = null)
-			where TResponse : class, ITransportResponse, new();
-
-		/// <inheritdoc cref="Request{TResponse}" />
-		Task<TResponse> RequestAsync<TResponse>(
-			HttpMethod method,
-			string path,
-			PostData data = null,
-			IRequestParameters requestParameters = null,
-			CancellationToken cancellationToken = default)
-			where TResponse : class, ITransportResponse, new();
-	}
-
-	/// <summary>
-	/// Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
-	/// different nodes
-	/// </summary>
-	public interface ITransport<out TConfiguration> : ITransport
-		where TConfiguration : ITransportConfiguration
-	{
-		/// <summary>
-		/// The <see cref="ITransportConfiguration" /> in use by this transport instance
-		/// </summary>
-		TConfiguration Settings { get; }
-	}
-}
diff --git a/src/Elastic.Transport/Products/DefaultProductRegistration.cs b/src/Elastic.Transport/Products/DefaultProductRegistration.cs
index 77fd01c..6c2dcb7 100644
--- a/src/Elastic.Transport/Products/DefaultProductRegistration.cs
+++ b/src/Elastic.Transport/Products/DefaultProductRegistration.cs
@@ -7,84 +7,82 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport.Products
+namespace Elastic.Transport.Products;
+
+/// <summary>
+/// A default non-descriptive product registration that does not support sniffing and pinging.
+/// Can be used to connect to unknown services before they develop their own <see cref="ProductRegistration"/>
+/// implementations
+/// </summary>
+public sealed class DefaultProductRegistration : ProductRegistration
 {
+	private readonly HeadersList _headers = new();
+	private readonly MetaHeaderProvider _metaHeaderProvider;
+
 	/// <summary>
-	/// A default non-descriptive product registration that does not support sniffing and pinging.
-	/// Can be used to connect to unknown services before they develop their own <see cref="IProductRegistration"/>
-	/// implementations
+	/// 
 	/// </summary>
-	public sealed class ProductRegistration : IProductRegistration
-	{
-		private readonly HeadersList _headers = new();
-		private readonly MetaHeaderProvider _metaHeaderProvider;
-
-		/// <summary>
-		/// 
-		/// </summary>
-		public ProductRegistration() => _metaHeaderProvider = new DefaultMetaHeaderProvider(typeof(ITransport), "et");
+	public DefaultProductRegistration() => _metaHeaderProvider = new DefaultMetaHeaderProvider(typeof(HttpTransport), "et");
 
-		/// <summary> A static instance of <see cref="ProductRegistration"/> to promote reuse </summary>
-		public static ProductRegistration Default { get; } = new ProductRegistration();
+	/// <summary> A static instance of <see cref="DefaultProductRegistration"/> to promote reuse </summary>
+	public static DefaultProductRegistration Default { get; } = new DefaultProductRegistration();
 
-		/// <inheritdoc cref="IProductRegistration.Name"/>
-		public string Name { get; } = "elastic-transport-net";
+	/// <inheritdoc cref="ProductRegistration.Name"/>
+	public override string Name { get; } = "elastic-transport-net";
 
-		/// <inheritdoc cref="IProductRegistration.SupportsPing"/>
-		public bool SupportsPing { get; } = false;
+	/// <inheritdoc cref="ProductRegistration.SupportsPing"/>
+	public override bool SupportsPing { get; } = false;
 
-		/// <inheritdoc cref="IProductRegistration.SupportsSniff"/>
-		public bool SupportsSniff { get; } = false;
+	/// <inheritdoc cref="ProductRegistration.SupportsSniff"/>
+	public override bool SupportsSniff { get; } = false;
 
-		/// <inheritdoc cref="IProductRegistration.SniffOrder"/>
-		public int SniffOrder(Node node) => -1;
+	/// <inheritdoc cref="ProductRegistration.SniffOrder"/>
+	public override int SniffOrder(Node node) => -1;
 
-		/// <inheritdoc cref="IProductRegistration.NodePredicate"/>
-		public bool NodePredicate(Node node) => true;
+	/// <inheritdoc cref="ProductRegistration.NodePredicate"/>
+	public override bool NodePredicate(Node node) => true;
 
-		/// <inheritdoc cref="IProductRegistration.ResponseHeadersToParse"/>
-		public HeadersList ResponseHeadersToParse => _headers;
+	/// <inheritdoc cref="ProductRegistration.ResponseHeadersToParse"/>
+	public override HeadersList ResponseHeadersToParse => _headers;
 
-		/// <inheritdoc cref="IProductRegistration.MetaHeaderProvider"/>
-		public MetaHeaderProvider MetaHeaderProvider => _metaHeaderProvider;
+	/// <inheritdoc cref="ProductRegistration.MetaHeaderProvider"/>
+	public override MetaHeaderProvider MetaHeaderProvider => _metaHeaderProvider;
 
-		/// <inheritdoc cref="IProductRegistration.ResponseBuilder"/>
-		public ResponseBuilder ResponseBuilder => new DefaultResponseBuilder<EmptyError>();
+	/// <inheritdoc cref="ProductRegistration.ResponseBuilder"/>
+	public override ResponseBuilder ResponseBuilder => new DefaultResponseBuilder<EmptyError>();
 
-		/// <inheritdoc cref="IProductRegistration.HttpStatusCodeClassifier"/>
-		public bool HttpStatusCodeClassifier(HttpMethod method, int statusCode) =>
-			statusCode >= 200 && statusCode < 300;
+	/// <inheritdoc cref="ProductRegistration.HttpStatusCodeClassifier"/>
+	public override bool HttpStatusCodeClassifier(HttpMethod method, int statusCode) =>
+		statusCode >= 200 && statusCode < 300;
 
-		/// <inheritdoc cref="IProductRegistration.TryGetServerErrorReason{TResponse}"/>>
-		public bool TryGetServerErrorReason<TResponse>(TResponse response, out string reason)
-			where TResponse : ITransportResponse
-		{
-			reason = null;
-			return false;
-		}
+	/// <inheritdoc cref="ProductRegistration.TryGetServerErrorReason{TResponse}"/>>
+	public override bool TryGetServerErrorReason<TResponse>(TResponse response, out string reason)
+	{
+		reason = null;
+		return false;
+	}
 
-		/// <inheritdoc cref="IProductRegistration.CreateSniffRequestData"/>
-		public RequestData CreateSniffRequestData(Node node, IRequestConfiguration requestConfiguration, ITransportConfiguration settings, IMemoryStreamFactory memoryStreamFactory) =>
-			throw new NotImplementedException();
+	/// <inheritdoc cref="ProductRegistration.CreateSniffRequestData"/>
+	public override RequestData CreateSniffRequestData(Node node, IRequestConfiguration requestConfiguration, ITransportConfiguration settings, MemoryStreamFactory memoryStreamFactory) =>
+		throw new NotImplementedException();
 
-		/// <inheritdoc cref="IProductRegistration.SniffAsync"/>
-		public Task<Tuple<IApiCallDetails, IReadOnlyCollection<Node>>> SniffAsync(ITransportClient transportClient, bool forceSsl, RequestData requestData, CancellationToken cancellationToken) =>
-			throw new NotImplementedException();
+	/// <inheritdoc cref="ProductRegistration.SniffAsync"/>
+	public override Task<Tuple<TransportResponse, IReadOnlyCollection<Node>>> SniffAsync(TransportClient transportClient, bool forceSsl, RequestData requestData, CancellationToken cancellationToken) =>
+		throw new NotImplementedException();
 
-		/// <inheritdoc cref="IProductRegistration.Sniff"/>
-		public Tuple<IApiCallDetails, IReadOnlyCollection<Node>> Sniff(ITransportClient connection, bool forceSsl, RequestData requestData) =>
-			throw new NotImplementedException();
+	/// <inheritdoc cref="ProductRegistration.Sniff"/>
+	public override Tuple<TransportResponse, IReadOnlyCollection<Node>> Sniff(TransportClient connection, bool forceSsl, RequestData requestData) =>
+		throw new NotImplementedException();
 
-		/// <inheritdoc cref="IProductRegistration.CreatePingRequestData"/>
-		public RequestData CreatePingRequestData(Node node, RequestConfiguration requestConfiguration, ITransportConfiguration global, IMemoryStreamFactory memoryStreamFactory) =>
-			throw new NotImplementedException();
+	/// <inheritdoc cref="ProductRegistration.CreatePingRequestData"/>
+	public override RequestData CreatePingRequestData(Node node, RequestConfiguration requestConfiguration, ITransportConfiguration global, MemoryStreamFactory memoryStreamFactory) =>
+		throw new NotImplementedException();
 
-		/// <inheritdoc cref="IProductRegistration.PingAsync"/>
-		public Task<IApiCallDetails> PingAsync(ITransportClient connection, RequestData pingData, CancellationToken cancellationToken) =>
-			throw new NotImplementedException();
+	/// <inheritdoc cref="ProductRegistration.PingAsync"/>
+	public override Task<TransportResponse> PingAsync(TransportClient connection, RequestData pingData, CancellationToken cancellationToken) =>
+		throw new NotImplementedException();
 
-		/// <inheritdoc cref="IProductRegistration.Ping"/>
-		public IApiCallDetails Ping(ITransportClient connection, RequestData pingData) =>
-			throw new NotImplementedException();
-	}
+	/// <inheritdoc cref="ProductRegistration.Ping"/>
+	public override TransportResponse Ping(TransportClient connection, RequestData pingData) =>
+		throw new NotImplementedException();
 }
diff --git a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchErrorExtensions.cs b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchErrorExtensions.cs
index 01fafd7..040dcf4 100644
--- a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchErrorExtensions.cs
+++ b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchErrorExtensions.cs
@@ -4,51 +4,50 @@
 
 using System.Text;
 
-namespace Elastic.Transport.Products.Elasticsearch
+namespace Elastic.Transport.Products.Elasticsearch;
+
+/// <summary>
+/// Extends the builtin responses with parsing for <see cref="ElasticsearchServerError"/>
+/// </summary>
+public static class ElasticsearchErrorExtensions
 {
+	/// <summary> Try to parse an Elasticsearch <see cref="ElasticsearchServerError"/> </summary>
+	public static bool TryGetElasticsearchServerError(this StringResponse response, out ElasticsearchServerError serverError)
+	{
+		serverError = null;
+		if (string.IsNullOrEmpty(response.Body) || response.ApiCallDetails.ResponseMimeType != RequestData.MimeType)
+			return false;
+
+		var settings = response.ApiCallDetails.TransportConfiguration;
+		using var stream = settings.MemoryStreamFactory.Create(Encoding.UTF8.GetBytes(response.Body));
+		return ElasticsearchServerError.TryCreate(stream, out serverError);
+	}
+
+	/// <summary> Try to parse an Elasticsearch <see cref="ElasticsearchServerError"/> </summary>
+	public static bool TryGetElasticsearchServerError(this BytesResponse response, out ElasticsearchServerError serverError)
+	{
+		serverError = null;
+		if (response.Body == null || response.Body.Length == 0 || response.ApiCallDetails.ResponseMimeType != RequestData.MimeType)
+			return false;
+
+		var settings = response.ApiCallDetails.TransportConfiguration;
+		using var stream = settings.MemoryStreamFactory.Create(response.Body);
+		return ElasticsearchServerError.TryCreate(stream, out serverError);
+	}
+
 	/// <summary>
-	/// Extends the builtin responses with parsing for <see cref="ServerError"/>
+	/// Try to parse an Elasticsearch <see cref="ElasticsearchServerError"/>, this only works if
+	/// <see cref="ITransportConfiguration.DisableDirectStreaming"/> gives us access to <see cref="ApiCallDetails.RequestBodyInBytes"/>
 	/// </summary>
-	public static class ElasticsearchErrorExtensions
+	public static bool TryGetElasticsearchServerError(this TransportResponse response, out ElasticsearchServerError serverError)
 	{
-		/// <summary> Try to parse an Elasticsearch <see cref="ServerError"/> </summary>
-		public static bool TryGetElasticsearchServerError(this StringResponse response, out ServerError serverError)
-		{
-			serverError = null;
-			if (string.IsNullOrEmpty(response.Body) || response.ResponseMimeType != RequestData.MimeType)
-				return false;
-
-			var settings = response.ApiCall.TransportConfiguration;
-			using var stream = settings.MemoryStreamFactory.Create(Encoding.UTF8.GetBytes(response.Body));
-			return ServerError.TryCreate(stream, out serverError);
-		}
-
-		/// <summary> Try to parse an Elasticsearch <see cref="ServerError"/> </summary>
-		public static bool TryGetElasticsearchServerError(this BytesResponse response, out ServerError serverError)
-		{
-			serverError = null;
-			if (response.Body == null || response.Body.Length == 0 || response.ResponseMimeType != RequestData.MimeType)
-				return false;
-
-			var settings = response.ApiCall.TransportConfiguration;
-			using var stream = settings.MemoryStreamFactory.Create(response.Body);
-			return ServerError.TryCreate(stream, out serverError);
-		}
-
-		/// <summary>
-		/// Try to parse an Elasticsearch <see cref="ServerError"/>, this only works if
-		/// <see cref="ITransportConfiguration.DisableDirectStreaming"/> gives us access to <see cref="IApiCallDetails.RequestBodyInBytes"/>
-		/// </summary>
-		public static bool TryGetElasticsearchServerError(this ITransportResponse response, out ServerError serverError)
-		{
-			serverError = null;
-			var bytes = response.ApiCall.ResponseBodyInBytes;
-			if (bytes == null || response.ApiCall.ResponseMimeType != RequestData.MimeType)
-				return false;
-
-			var settings = response.ApiCall.TransportConfiguration;
-			using var stream = settings.MemoryStreamFactory.Create(bytes);
-			return ServerError.TryCreate(stream, out serverError);
-		}
+		serverError = null;
+		var bytes = response.ApiCallDetails.ResponseBodyInBytes;
+		if (bytes == null || response.ApiCallDetails.ResponseMimeType != RequestData.MimeType)
+			return false;
+
+		var settings = response.ApiCallDetails.TransportConfiguration;
+		using var stream = settings.MemoryStreamFactory.Create(bytes);
+		return ElasticsearchServerError.TryCreate(stream, out serverError);
 	}
 }
diff --git a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchNodeFeatures.cs b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchNodeFeatures.cs
index e2c66eb..d1b852a 100644
--- a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchNodeFeatures.cs
+++ b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchNodeFeatures.cs
@@ -5,36 +5,35 @@
 using System.Collections.Generic;
 using System.Linq;
 
-namespace Elastic.Transport.Products.Elasticsearch
+namespace Elastic.Transport.Products.Elasticsearch;
+
+/// <summary>
+/// Encodes the features <see cref="ElasticsearchProductRegistration.Sniff"/> will register on
+/// <see cref="Node.Features"/>. These static strings make it easier to inspect if features are enabled
+/// using <see cref="Node.HasFeature"/>
+/// </summary>
+public static class ElasticsearchNodeFeatures
 {
-	/// <summary>
-	/// Encodes the features <see cref="ElasticsearchProductRegistration.Sniff"/> will register on
-	/// <see cref="Node.Features"/>. These static strings make it easier to inspect if features are enabled
-	/// using <see cref="Node.HasFeature"/>
-	/// </summary>
-	public static class ElasticsearchNodeFeatures
-	{
-		/// <summary>Indicates whether this node holds data, defaults to true when unknown/unspecified</summary>
-		public const string HoldsData = "node.data";
-		/// <summary>Whether HTTP is enabled on the node or not</summary>
-		public const string HttpEnabled = "node.http";
-		/// <summary>Indicates whether this node is allowed to run ingest pipelines, defaults to true when unknown/unspecified</summary>
-		public const string IngestEnabled = "node.ingest";
-		/// <summary>Indicates whether this node is master eligible, defaults to true when unknown/unspecified</summary>
-		public const string MasterEligible = "node.master";
+	/// <summary>Indicates whether this node holds data, defaults to true when unknown/unspecified</summary>
+	public const string HoldsData = "node.data";
+	/// <summary>Whether HTTP is enabled on the node or not</summary>
+	public const string HttpEnabled = "node.http";
+	/// <summary>Indicates whether this node is allowed to run ingest pipelines, defaults to true when unknown/unspecified</summary>
+	public const string IngestEnabled = "node.ingest";
+	/// <summary>Indicates whether this node is master eligible, defaults to true when unknown/unspecified</summary>
+	public const string MasterEligible = "node.master";
 
-		/// <summary> The default collection of features, which enables ALL Features </summary>
-		public static readonly IReadOnlyCollection<string> Default =
-			new[] { HoldsData, MasterEligible, IngestEnabled, HttpEnabled }.ToList().AsReadOnly();
+	/// <summary> The default collection of features, which enables ALL Features </summary>
+	public static readonly IReadOnlyCollection<string> Default =
+		new[] { HoldsData, MasterEligible, IngestEnabled, HttpEnabled }.ToList().AsReadOnly();
 
-		/// <summary> The node only has the <see cref="MasterEligible"/> and <see cref="HttpEnabled"/> features</summary>
-		public static readonly IReadOnlyCollection<string> MasterEligibleOnly =
-			new[] { MasterEligible, HttpEnabled }.ToList().AsReadOnly();
+	/// <summary> The node only has the <see cref="MasterEligible"/> and <see cref="HttpEnabled"/> features</summary>
+	public static readonly IReadOnlyCollection<string> MasterEligibleOnly =
+		new[] { MasterEligible, HttpEnabled }.ToList().AsReadOnly();
 
-		/// <summary> The node has all features EXCEPT <see cref="MasterEligible"/></summary>
-		// ReSharper disable once UnusedMember.Global
-		public static readonly IReadOnlyCollection<string> NotMasterEligible =
-			Default.Except(new[] { MasterEligible }).ToList().AsReadOnly();
+	/// <summary> The node has all features EXCEPT <see cref="MasterEligible"/></summary>
+	// ReSharper disable once UnusedMember.Global
+	public static readonly IReadOnlyCollection<string> NotMasterEligible =
+		Default.Except(new[] { MasterEligible }).ToList().AsReadOnly();
 
-	}
 }
diff --git a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchProductRegistration.cs b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchProductRegistration.cs
index 31e8617..eab5560 100644
--- a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchProductRegistration.cs
+++ b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchProductRegistration.cs
@@ -9,144 +9,148 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport.Products.Elasticsearch
+namespace Elastic.Transport.Products.Elasticsearch;
+
+/// <summary>
+/// An implementation of <see cref="ProductRegistration"/> that fills in the bespoke implementations
+/// for Elasticsearch so that <see cref="RequestPipeline"/> knows how to ping and sniff if we setup
+/// <see cref="HttpTransport{TConnectionSettings}"/> to talk to Elasticsearch
+/// </summary>
+public class ElasticsearchProductRegistration : ProductRegistration
 {
+	private readonly HeadersList _headers;
+	private readonly MetaHeaderProvider _metaHeaderProvider;
+
+	/// <summary>
+	/// Create a new instance of the Elasticsearch product registration.
+	/// </summary>
+	public ElasticsearchProductRegistration() => _headers = new HeadersList("warning");
+
 	/// <summary>
-	/// An implementation of <see cref="IProductRegistration"/> that fills in the bespoke implementations
-	/// for Elasticsearch so that <see cref="IRequestPipeline"/> knows how to ping and sniff if we setup
-	/// <see cref="ITransport{TConnectionSettings}"/> to talk to Elasticsearch
+	/// 
 	/// </summary>
-	public class ElasticsearchProductRegistration : IProductRegistration
+	/// <param name="markerType"></param>
+	public ElasticsearchProductRegistration(Type markerType) : this() => _metaHeaderProvider = new DefaultMetaHeaderProvider(markerType, "es");
+
+	/// <summary> A static instance of <see cref="ElasticsearchProductRegistration"/> to promote reuse </summary>
+	public static ProductRegistration Default { get; } = new ElasticsearchProductRegistration();
+
+	/// <inheritdoc cref="ProductRegistration.Name"/>
+	public override string Name { get; } = "elasticsearch-net";
+
+	/// <inheritdoc cref="ProductRegistration.SupportsPing"/>
+	public override bool SupportsPing { get; } = true;
+
+	/// <inheritdoc cref="ProductRegistration.SupportsSniff"/>
+	public override bool SupportsSniff { get; } = true;
+
+	/// <inheritdoc cref="ProductRegistration.ResponseHeadersToParse"/>
+	public override HeadersList ResponseHeadersToParse => _headers;
+
+	/// <inheritdoc cref="ProductRegistration.MetaHeaderProvider"/>
+	public override MetaHeaderProvider MetaHeaderProvider => _metaHeaderProvider;
+
+	/// <inheritdoc cref="ProductRegistration.ResponseBuilder"/>
+	public override ResponseBuilder ResponseBuilder => new ElasticsearchResponseBuilder();
+
+	/// <summary> Exposes the path used for sniffing in Elasticsearch </summary>
+	public const string SniffPath = "_nodes/http,settings";
+
+	/// <summary>
+	/// Implements an ordering that prefers master eligible nodes when attempting to sniff the
+	/// <see cref="NodePool.Nodes"/>
+	/// </summary>
+	public override int SniffOrder(Node node) =>
+		node.HasFeature(ElasticsearchNodeFeatures.MasterEligible) ? node.Uri.Port : int.MaxValue;
+
+	/// <summary>
+	/// If we know that a node is a master eligible node that hold no data it is excluded from regular
+	/// API calls. They are considered for ping and sniff requests.
+	/// </summary>
+	public override bool NodePredicate(Node node) =>
+		// skip master only nodes (holds no data and is master eligible)
+		!(node.HasFeature(ElasticsearchNodeFeatures.MasterEligible) &&
+		  !node.HasFeature(ElasticsearchNodeFeatures.HoldsData));
+
+	/// <inheritdoc cref="ProductRegistration.HttpStatusCodeClassifier"/>
+	public override bool HttpStatusCodeClassifier(HttpMethod method, int statusCode) =>
+		statusCode >= 200 && statusCode < 300;
+
+	/// <inheritdoc cref="ProductRegistration.TryGetServerErrorReason{TResponse}"/>>
+	public override bool TryGetServerErrorReason<TResponse>(TResponse response, out string reason)
 	{
-		private readonly HeadersList _headers;
-		private readonly MetaHeaderProvider _metaHeaderProvider;
-
-		/// <summary>
-		/// Create a new instance of the Elasticsearch product registration.
-		/// </summary>
-		public ElasticsearchProductRegistration() => _headers = new HeadersList("warning");
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="markerType"></param>
-		public ElasticsearchProductRegistration(Type markerType) : this() => _metaHeaderProvider = new DefaultMetaHeaderProvider(markerType, "es");
-
-		/// <summary> A static instance of <see cref="ElasticsearchProductRegistration"/> to promote reuse </summary>
-		public static IProductRegistration Default { get; } = new ElasticsearchProductRegistration();
-
-		/// <inheritdoc cref="IProductRegistration.Name"/>
-		public string Name { get; } = "elasticsearch-net";
-
-		/// <inheritdoc cref="IProductRegistration.SupportsPing"/>
-		public bool SupportsPing { get; } = true;
-
-		/// <inheritdoc cref="IProductRegistration.SupportsSniff"/>
-		public bool SupportsSniff { get; } = true;
-
-		/// <inheritdoc cref="IProductRegistration.ResponseHeadersToParse"/>
-		public HeadersList ResponseHeadersToParse => _headers;
-
-		/// <inheritdoc cref="IProductRegistration.MetaHeaderProvider"/>
-		public MetaHeaderProvider MetaHeaderProvider => _metaHeaderProvider;
-
-		/// <inheritdoc cref="IProductRegistration.ResponseBuilder"/>
-		public ResponseBuilder ResponseBuilder => new ElasticsearchResponseBuilder();
-
-		/// <summary> Exposes the path used for sniffing in Elasticsearch </summary>
-		public const string SniffPath = "_nodes/http,settings";
-
-		/// <summary>
-		/// Implements an ordering that prefers master eligible nodes when attempting to sniff the
-		/// <see cref="NodePool.Nodes"/>
-		/// </summary>
-		public int SniffOrder(Node node) =>
-			node.HasFeature(ElasticsearchNodeFeatures.MasterEligible) ? node.Uri.Port : int.MaxValue;
-
-		/// <summary>
-		/// If we know that a node is a master eligible node that hold no data it is excluded from regular
-		/// API calls. They are considered for ping and sniff requests.
-		/// </summary>
-		public bool NodePredicate(Node node) =>
-			// skip master only nodes (holds no data and is master eligible)
-			!(node.HasFeature(ElasticsearchNodeFeatures.MasterEligible) &&
-			  !node.HasFeature(ElasticsearchNodeFeatures.HoldsData));
-
-		/// <inheritdoc cref="IProductRegistration.HttpStatusCodeClassifier"/>
-		public virtual bool HttpStatusCodeClassifier(HttpMethod method, int statusCode) =>
-			statusCode >= 200 && statusCode < 300;
-
-		/// <inheritdoc cref="IProductRegistration.TryGetServerErrorReason{TResponse}"/>>
-		public virtual bool TryGetServerErrorReason<TResponse>(TResponse response, out string reason)
-			where TResponse : ITransportResponse
-		{
-			reason = null;
-			if (response is StringResponse s && s.TryGetElasticsearchServerError(out var e)) reason = e.Error?.ToString();
-			else if (response is BytesResponse b && b.TryGetElasticsearchServerError(out e)) reason = e.Error?.ToString();
-			else if (response.TryGetElasticsearchServerError(out e)) reason = e.Error?.ToString();
-			return e != null;
-		}
-
-		/// <inheritdoc cref="IProductRegistration.CreateSniffRequestData"/>
-		public RequestData CreateSniffRequestData(Node node, IRequestConfiguration requestConfiguration,
-			ITransportConfiguration settings,
-			IMemoryStreamFactory memoryStreamFactory
-		)
-		{
-			var requestParameters = new RequestParameters
-			{
-				QueryString = {{"timeout", requestConfiguration.PingTimeout}, {"flat_settings", true},}
-			};
-			return new RequestData(HttpMethod.GET, SniffPath, null, settings, requestParameters, memoryStreamFactory)
-			{
-				Node = node
-			};
-		}
-
-		/// <inheritdoc cref="IProductRegistration.SniffAsync"/>
-		public async Task<Tuple<IApiCallDetails, IReadOnlyCollection<Node>>> SniffAsync(ITransportClient transportClient,
-			bool forceSsl, RequestData requestData, CancellationToken cancellationToken)
+		reason = null;
+		if (response is StringResponse s && s.TryGetElasticsearchServerError(out var e)) reason = e.Error?.ToString();
+		else if (response is BytesResponse b && b.TryGetElasticsearchServerError(out e)) reason = e.Error?.ToString();
+		else if (response.TryGetElasticsearchServerError(out e)) reason = e.Error?.ToString();
+		return e != null;
+	}
+
+	/// <inheritdoc cref="ProductRegistration.CreateSniffRequestData"/>
+	public override RequestData CreateSniffRequestData(Node node, IRequestConfiguration requestConfiguration,
+		ITransportConfiguration settings,
+		MemoryStreamFactory memoryStreamFactory
+	)
+	{
+		var requestParameters = new DefaultRequestParameters
 		{
-			var response = await transportClient.RequestAsync<SniffResponse>(requestData, cancellationToken)
-				.ConfigureAwait(false);
-			var nodes = response.ToNodes(forceSsl);
-			return Tuple.Create<IApiCallDetails, IReadOnlyCollection<Node>>(response,
-				new ReadOnlyCollection<Node>(nodes.ToArray()));
-		}
-
-		/// <inheritdoc cref="IProductRegistration.Sniff"/>
-		public Tuple<IApiCallDetails, IReadOnlyCollection<Node>> Sniff(ITransportClient transportClient, bool forceSsl,
-			RequestData requestData)
+			QueryString = {{"timeout", requestConfiguration.PingTimeout}, {"flat_settings", true},}
+		};
+		return new RequestData(HttpMethod.GET, SniffPath, null, settings, requestParameters, memoryStreamFactory)
 		{
-			var response = transportClient.Request<SniffResponse>(requestData);
-			var nodes = response.ToNodes(forceSsl);
-			return Tuple.Create<IApiCallDetails, IReadOnlyCollection<Node>>(response,
-				new ReadOnlyCollection<Node>(nodes.ToArray()));
-		}
-
-		/// <inheritdoc cref="IProductRegistration.CreatePingRequestData"/>
-		public RequestData CreatePingRequestData(Node node, RequestConfiguration requestConfiguration,
-			ITransportConfiguration global,
-			IMemoryStreamFactory memoryStreamFactory
-		)
+			Node = node
+		};
+	}
+
+	/// <inheritdoc cref="ProductRegistration.SniffAsync"/>
+	public override async Task<Tuple<TransportResponse, IReadOnlyCollection<Node>>> SniffAsync(TransportClient transportClient,
+		bool forceSsl, RequestData requestData, CancellationToken cancellationToken)
+	{
+		var response = await transportClient.RequestAsync<SniffResponse>(requestData, cancellationToken)
+			.ConfigureAwait(false);
+		var nodes = response.ToNodes(forceSsl);
+		return Tuple.Create<TransportResponse, IReadOnlyCollection<Node>>(response,
+			new ReadOnlyCollection<Node>(nodes.ToArray()));
+	}
+
+	/// <inheritdoc cref="ProductRegistration.Sniff"/>
+	public override Tuple<TransportResponse, IReadOnlyCollection<Node>> Sniff(TransportClient transportClient, bool forceSsl,
+		RequestData requestData)
+	{
+		var response = transportClient.Request<SniffResponse>(requestData);
+		var nodes = response.ToNodes(forceSsl);
+		return Tuple.Create<TransportResponse, IReadOnlyCollection<Node>>(response,
+			new ReadOnlyCollection<Node>(nodes.ToArray()));
+	}
+
+	/// <inheritdoc cref="ProductRegistration.CreatePingRequestData"/>
+	public override RequestData CreatePingRequestData(Node node, RequestConfiguration requestConfiguration,
+		ITransportConfiguration global,
+		MemoryStreamFactory memoryStreamFactory
+	)
+	{
+		var requestParameters = new DefaultRequestParameters
 		{
-			IRequestParameters requestParameters = new RequestParameters
-			{
-				RequestConfiguration = requestConfiguration
-			};
-
-			var data = new RequestData(HttpMethod.HEAD, string.Empty, null, global, requestParameters,
-				memoryStreamFactory) {Node = node};
-			return data;
-		}
-
-		/// <inheritdoc cref="IProductRegistration.PingAsync"/>
-		public async Task<IApiCallDetails> PingAsync(ITransportClient transportClient, RequestData pingData,
-			CancellationToken cancellationToken) =>
-			await transportClient.RequestAsync<VoidResponse>(pingData, cancellationToken).ConfigureAwait(false);
-
-		/// <inheritdoc cref="IProductRegistration.Ping"/>
-		public IApiCallDetails Ping(ITransportClient connection, RequestData pingData) =>
-			connection.Request<VoidResponse>(pingData);
+			RequestConfiguration = requestConfiguration
+		};
+
+		var data = new RequestData(HttpMethod.HEAD, string.Empty, null, global, requestParameters,
+			memoryStreamFactory) {Node = node};
+		return data;
+	}
+
+	/// <inheritdoc cref="ProductRegistration.PingAsync"/>
+	public override async Task<TransportResponse> PingAsync(TransportClient transportClient, RequestData pingData,
+		CancellationToken cancellationToken)
+	{
+		var response = await transportClient.RequestAsync<VoidResponse>(pingData, cancellationToken).ConfigureAwait(false);
+		return response;
+	}
+
+	/// <inheritdoc cref="ProductRegistration.Ping"/>
+	public override TransportResponse Ping(TransportClient connection, RequestData pingData)
+	{
+		var response = connection.Request<VoidResponse>(pingData);
+		return response;
 	}
 }
diff --git a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchResponse.cs b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchResponse.cs
index 69a9e04..6cac0a2 100644
--- a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchResponse.cs
+++ b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchResponse.cs
@@ -7,118 +7,110 @@
 using System.Text;
 using System.Text.Json.Serialization;
 
-namespace Elastic.Transport.Products.Elasticsearch
+namespace Elastic.Transport.Products.Elasticsearch;
+
+/// <summary>
+/// Base response for Elasticsearch responses.
+/// </summary>
+public abstract class ElasticsearchResponse : TransportResponse
 {
 	/// <summary>
-	/// Base response for Elasticsearch responses.
+	/// A collection of warnings returned from Elasticsearch.
+	/// <para>Used to provide server warnings, for example, when the request uses an API feature that is marked as deprecated.</para>
 	/// </summary>
-	public abstract class ElasticsearchResponse : IElasticsearchResponse
+	[JsonIgnore]
+	public IEnumerable<string> ElasticsearchWarnings
 	{
-		private IApiCallDetails? _originalApiCall;
-		
-		/// <summary> Returns useful information about the request(s) that were part of this API call. </summary>
-		[JsonIgnore]
-		public virtual IApiCallDetails? ApiCall => _originalApiCall;
-
-		/// <summary>
-		/// A collection of warnings returned from Elasticsearch.
-		/// <para>Used to provide server warnings, for example, when the request uses an API feature that is marked as deprecated.</para>
-		/// </summary>
-		[JsonIgnore]
-		public IEnumerable<string> Warnings
+		get
 		{
-			get
+			if (ApiCallDetails.ParsedHeaders is not null && ApiCallDetails.ParsedHeaders.TryGetValue("warning", out var warnings))
 			{
-				if (ApiCall.ParsedHeaders is not null && ApiCall.ParsedHeaders.TryGetValue("warning", out var warnings))
-				{
-					foreach (var warning in warnings)
-						yield return warning;
-				}
+				foreach (var warning in warnings)
+					yield return warning;
 			}
 		}
+	}
 
-		/// <inheritdoc />
-		[JsonIgnore]
-		public string DebugInformation
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <returns></returns>
+	[JsonIgnore]
+	public string DebugInformation
+	{
+		get
 		{
-			get
+			var sb = new StringBuilder();
+			sb.Append($"{(!IsValid ? "Inv" : "V")}alid Elastic.Clients.Elasticsearch response built from a ");
+			sb.AppendLine(ApiCallDetails?.ToString().ToCamelCase() ??
+						"null ApiCall which is highly exceptional, please open a bug if you see this");
+			if (!IsValid)
+				DebugIsValid(sb);
+
+			if (ApiCallDetails.ParsedHeaders is not null && ApiCallDetails.ParsedHeaders.TryGetValue("warning", out var warnings))
 			{
-				var sb = new StringBuilder();
-				sb.Append($"{(!IsValid ? "Inv" : "V")}alid Elastic.Clients.Elasticsearch response built from a ");
-				sb.AppendLine(ApiCall?.ToString().ToCamelCase() ??
-							"null ApiCall which is highly exceptional, please open a bug if you see this");
-				if (!IsValid)
-					DebugIsValid(sb);
-
-				if (ApiCall.ParsedHeaders is not null && ApiCall.ParsedHeaders.TryGetValue("warning", out var warnings))
-				{
-					sb.AppendLine($"# Server indicated warnings:");
-
-					foreach (var warning in warnings)
-						sb.AppendLine($"- {warning}");
-				}
+				sb.AppendLine($"# Server indicated warnings:");
 
-				if (ApiCall != null)
-					ResponseStatics.DebugInformationBuilder(ApiCall, sb);
-				return sb.ToString();
+				foreach (var warning in warnings)
+					sb.AppendLine($"- {warning}");
 			}
+
+			if (ApiCallDetails != null)
+				Diagnostics.ResponseStatics.DebugInformationBuilder(ApiCallDetails, sb);
+			return sb.ToString();
 		}
+	}
 
-		/// <inheritdoc />
-		[JsonIgnore]
-		public virtual bool IsValid
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <returns></returns>
+	[JsonIgnore]
+	public virtual bool IsValid
+	{
+		get
 		{
-			get
-			{
-				var statusCode = ApiCall?.HttpStatusCode;
+			var statusCode = ApiCallDetails?.HttpStatusCode;
 
-				// TODO - Review this on a request by reqeust basis
-				if (statusCode == 404)
-					return false;
+			// TODO - Review this on a request by reqeust basis
+			if (statusCode == 404)
+				return false;
 
-				return (ApiCall?.Success ?? false) && (!ServerError?.HasError() ?? true);
-			}
+			return (ApiCallDetails?.Success ?? false) && (!ServerError?.HasError() ?? true);
 		}
+	}
 
-		/// <inheritdoc />
-		[JsonIgnore]
-		public Exception? OriginalException => ApiCall?.OriginalException;
+	/// <summary>
+	/// 
+	/// </summary>
+	[JsonIgnore]
+	public ElasticsearchServerError ServerError { get; internal set; }
 
-		IApiCallDetails? ITransportResponse.ApiCall
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="exception"></param>
+	/// <returns></returns>
+	// TODO: We need nullable annotations here ideally as exception is not null when the return value is true.
+	public bool TryGetOriginalException(out Exception? exception)
+	{
+		if (ApiCallDetails.OriginalException is not null)
 		{
-			get => _originalApiCall;
-			set => _originalApiCall = value;
+			exception = ApiCallDetails.OriginalException;
+			return true;
 		}
 
-		/// <summary>
-		/// 
-		/// </summary>
-		[JsonIgnore]
-		public ServerError ServerError { get; internal set; }
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="exception"></param>
-		/// <returns></returns>
-		// TODO: We need nullable annotations here ideally as exception is not null when the return value is true.
-		public bool TryGetOriginalException(out Exception? exception)
-		{
-			if (OriginalException is not null)
-			{
-				exception = OriginalException;
-				return true;
-			}
-
-			exception = null;
-			return false;
-		}
+		exception = null;
+		return false;
+	}
 
-		/// <summary>Subclasses can override this to provide more information on why a call is not valid.</summary>
-		protected virtual void DebugIsValid(StringBuilder sb) { }
+	/// <summary>Subclasses can override this to provide more information on why a call is not valid.</summary>
+	protected virtual void DebugIsValid(StringBuilder sb) { }
 
-		/// <inheritdoc />
-		public override string ToString() =>
-			$"{(!IsValid ? "Inv" : "V")}alid Elastic.Clients.Elasticsearch response built from a {ApiCall?.ToString().ToCamelCase()}";
-	}
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <returns></returns>
+	public override string ToString() =>
+		$"{(!IsValid ? "Inv" : "V")}alid Elastic.Clients.Elasticsearch response built from a {ApiCallDetails?.ToString().ToCamelCase()}";
 }
diff --git a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchResponseBuilder.cs b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchResponseBuilder.cs
index 0e95548..f155fb5 100644
--- a/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchResponseBuilder.cs
+++ b/src/Elastic.Transport/Products/Elasticsearch/ElasticsearchResponseBuilder.cs
@@ -6,43 +6,42 @@
 using System.IO;
 using System.Text.Json;
 
-namespace Elastic.Transport.Products.Elasticsearch
+namespace Elastic.Transport.Products.Elasticsearch;
+
+internal sealed class ElasticsearchResponseBuilder : DefaultResponseBuilder<ElasticsearchServerError>
 {
-	internal sealed class ElasticsearchResponseBuilder : DefaultResponseBuilder<ServerError>
+	protected override void SetErrorOnResponse<TResponse>(TResponse response, ElasticsearchServerError error)
 	{
-		protected override void SetErrorOnResponse<TResponse>(TResponse response, ServerError error)
+		if (response is ElasticsearchResponse elasticResponse)
 		{
-			if (response is ElasticsearchResponse elasticResponse)
-			{
-				elasticResponse.ServerError = error;
-			}
+			elasticResponse.ServerError = error;
 		}
+	}
+
+	protected override bool TryGetError(ApiCallDetails apiCallDetails, RequestData requestData, Stream responseStream, out ElasticsearchServerError error)
+	{
+		error = null;
+		
+		Debug.Assert(responseStream.CanSeek);
+
+		var serializer = requestData.ConnectionSettings.RequestResponseSerializer;
 
-		protected override bool TryGetError(ApiCallDetails apiCallDetails, RequestData requestData, Stream responseStream, out ServerError error)
+		try
 		{
-			error = null;
-			
-			Debug.Assert(responseStream.CanSeek);
-
-			var serializer = requestData.ConnectionSettings.RequestResponseSerializer;
-
-			try
-			{
-				error = serializer.Deserialize<ServerError>(responseStream);
-				return error is not null;
-			}
-			catch (JsonException)
-			{
-				// Empty catch as we'll try the original response type if the error serialization fails
-			}
-			finally
-			{
-				responseStream.Position = 0;
-			}
-
-			return false;
+			error = serializer.Deserialize<ElasticsearchServerError>(responseStream);
+			return error is not null;
+		}
+		catch (JsonException)
+		{
+			// Empty catch as we'll try the original response type if the error serialization fails
+		}
+		finally
+		{
+			responseStream.Position = 0;
 		}
 
-		protected sealed override bool RequiresErrorDeserialization(ApiCallDetails apiCallDetails, RequestData requestData) => apiCallDetails.HttpStatusCode > 399;
+		return false;
 	}
+
+	protected sealed override bool RequiresErrorDeserialization(ApiCallDetails apiCallDetails, RequestData requestData) => apiCallDetails.HttpStatusCode > 399;
 }
diff --git a/src/Elastic.Transport/Products/Elasticsearch/Failures/ElasticsearchServerError.cs b/src/Elastic.Transport/Products/Elasticsearch/Failures/ElasticsearchServerError.cs
new file mode 100644
index 0000000..3de79a8
--- /dev/null
+++ b/src/Elastic.Transport/Products/Elasticsearch/Failures/ElasticsearchServerError.cs
@@ -0,0 +1,83 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System.IO;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Text.Json.Serialization;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Elastic.Transport.Products.Elasticsearch;
+
+/// <summary> Represents the error response as returned by Elasticsearch. </summary>
+[DataContract]
+public sealed class ElasticsearchServerError : ErrorResponse
+{
+	/// <inheritdoc cref="ElasticsearchServerError"/>
+	public ElasticsearchServerError() { }
+
+	/// <inheritdoc cref="ElasticsearchServerError"/>
+	public ElasticsearchServerError(Error error, int? statusCode)
+	{
+		Error = error;
+		Status = statusCode.GetValueOrDefault(-1);
+	}
+
+	/// <summary> an <see cref="Error"/> object that represents the server exception that occurred</summary>
+	[DataMember(Name = "error")]
+	[JsonPropertyName("error")]
+	public Error Error { get; init; }
+
+	/// <summary> The HTTP status code returned from the server </summary>
+	[DataMember(Name = "status")]
+	[JsonPropertyName("status")]
+	public int Status { get; init; } = -1;
+
+	/// <summary>
+	/// Try and create an instance of <see cref="ElasticsearchServerError"/> from <paramref name="stream"/>
+	/// </summary>
+	/// <returns>Whether a an instance of <see cref="ElasticsearchServerError"/> was created successfully</returns>
+	public static bool TryCreate(Stream stream, out ElasticsearchServerError serverError)
+	{
+		try
+		{
+			serverError = Create(stream);
+			return serverError != null;
+		}
+		catch
+		{
+			serverError = null;
+			return false;
+		}
+	}
+
+	/// <summary>
+	/// Use the clients default <see cref="LowLevelRequestResponseSerializer"/> to create an instance
+	/// of <see cref="ElasticsearchServerError"/> from <paramref name="stream"/>
+	/// </summary>
+	public static ElasticsearchServerError Create(Stream stream) =>
+		LowLevelRequestResponseSerializer.Instance.Deserialize<ElasticsearchServerError>(stream);
+
+	// ReSharper disable once UnusedMember.Global
+	/// <inheritdoc cref="Create"/>
+	public static ValueTask<ElasticsearchServerError> CreateAsync(Stream stream, CancellationToken token = default) =>
+		LowLevelRequestResponseSerializer.Instance.DeserializeAsync<ElasticsearchServerError>(stream, token);
+
+	/// <summary> A human readable string representation of the server error returned by Elasticsearch </summary>
+	public override string ToString()
+	{
+		var sb = new StringBuilder();
+		sb.Append($"ServerError: {Status}");
+		if (Error != null)
+			sb.Append(Error);
+		return sb.ToString();
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <returns></returns>
+	public override bool HasError() => Status > 0 && Error is not null;
+}
diff --git a/src/Elastic.Transport/Products/Elasticsearch/Failures/Error.cs b/src/Elastic.Transport/Products/Elasticsearch/Failures/Error.cs
index 0bfd6a7..49fc399 100644
--- a/src/Elastic.Transport/Products/Elasticsearch/Failures/Error.cs
+++ b/src/Elastic.Transport/Products/Elasticsearch/Failures/Error.cs
@@ -5,131 +5,129 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
-using System.Diagnostics;
 using System.Runtime.Serialization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
-namespace Elastic.Transport.Products.Elasticsearch
+namespace Elastic.Transport.Products.Elasticsearch;
+
+/// <summary> Represents the serialized Elasticsearch java exception that caused a request to fail </summary>
+[DataContract]
+[JsonConverter(typeof(ErrorConverter))]
+public sealed class Error : ErrorCause
 {
-	/// <summary> Represents the serialized Elasticsearch java exception that caused a request to fail </summary>
-	[DataContract]
-	[JsonConverter(typeof(ErrorConverter))]
-	public class Error : ErrorCause
-	{
-		private static readonly IReadOnlyDictionary<string, string> DefaultHeaders =
-			new ReadOnlyDictionary<string, string>(new Dictionary<string, string>(0));
+	private static readonly IReadOnlyDictionary<string, string> DefaultHeaders =
+		new ReadOnlyDictionary<string, string>(new Dictionary<string, string>(0));
 
-		/// <summary> Additional headers from the request that pertain to the error</summary>
-		[JsonPropertyName("headers")]
-		public IReadOnlyDictionary<string, string> Headers { get; set; } = DefaultHeaders;
+	/// <summary> Additional headers from the request that pertain to the error</summary>
+	[JsonPropertyName("headers")]
+	public IReadOnlyDictionary<string, string> Headers { get; set; } = DefaultHeaders;
 
-		/// <summary> The root cause exception </summary>
-		[JsonPropertyName("root_cause")]
-		public IReadOnlyCollection<ErrorCause> RootCause { get; set; }
+	/// <summary> The root cause exception </summary>
+	[JsonPropertyName("root_cause")]
+	public IReadOnlyCollection<ErrorCause> RootCause { get; set; }
 
-		/// <summary> A human readable string representation of the exception returned by Elasticsearch </summary>
-		public override string ToString() => CausedBy == null
-			? $"Type: {Type} Reason: \"{Reason}\""
-			: $"Type: {Type} Reason: \"{Reason}\" CausedBy: \"{CausedBy}\"";
-	}
+	/// <summary> A human readable string representation of the exception returned by Elasticsearch </summary>
+	public override string ToString() => CausedBy == null
+		? $"Type: {Type} Reason: \"{Reason}\""
+		: $"Type: {Type} Reason: \"{Reason}\" CausedBy: \"{CausedBy}\"";
+}
 
-	internal sealed class ErrorConverter : JsonConverter<Error>
+internal sealed class ErrorConverter : JsonConverter<Error>
+{
+	public override Error Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
 	{
-		public override Error Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+		if (reader.TokenType == JsonTokenType.String)
 		{
-			if (reader.TokenType == JsonTokenType.String)
-			{
-				return new Error { Reason = reader.GetString() };
-			}
-			else if (reader.TokenType == JsonTokenType.StartObject)
-			{
-				var error = new Error();
-				Dictionary<string, object> additional = null;
+			return new Error { Reason = reader.GetString() };
+		}
+		else if (reader.TokenType == JsonTokenType.StartObject)
+		{
+			var error = new Error();
+			Dictionary<string, object> additional = null;
 
-				while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
+			while (reader.Read() && reader.TokenType != JsonTokenType.EndObject)
+			{
+				if (reader.TokenType == JsonTokenType.PropertyName)
 				{
-					if (reader.TokenType == JsonTokenType.PropertyName)
+					if (reader.ValueTextEquals("root_cause"))
 					{
-						if (reader.ValueTextEquals("root_cause"))
-						{
-							var value = JsonSerializer.Deserialize<IReadOnlyCollection<ErrorCause>>(ref reader, options);
-							error.RootCause = value;
-							continue;
-						}
-
-						if (reader.ValueTextEquals("caused_by"))
-						{
-							var value = JsonSerializer.Deserialize<ErrorCause>(ref reader, options);
-							error.CausedBy = value;
-							continue;
-						}
-
-						//if (reader.ValueTextEquals("suppressed"))
-						//{
-						//	var value = JsonSerializer.Deserialize<IReadOnlyCollection<ErrorCause>>(ref reader, options);
-						//	error.TODO = value;
-						//	continue;
-						//}
-
-						if (reader.ValueTextEquals("headers"))
-						{
-							var value = JsonSerializer.Deserialize<IReadOnlyDictionary<string, string>>(ref reader, options);
-							error.Headers = value;
-							continue;
-						}
-
-						if (reader.ValueTextEquals("stack_trace"))
-						{
-							var value = JsonSerializer.Deserialize<string>(ref reader, options);
-							error.StackTrace = value;
-							continue;
-						}
-
-						if (reader.ValueTextEquals("type"))
-						{
-							var value = JsonSerializer.Deserialize<string>(ref reader, options);
-							error.Type = value;
-							continue;
-						}
-
-						if (reader.ValueTextEquals("index"))
-						{
-							var value = JsonSerializer.Deserialize<string>(ref reader, options);
-							error.Index = value;
-							continue;
-						}
-
-						if (reader.ValueTextEquals("index_uuid"))
-						{
-							var value = JsonSerializer.Deserialize<string>(ref reader, options);
-							error.IndexUUID = value;
-							continue;
-						}
-
-						if (reader.ValueTextEquals("reason"))
-						{
-							var value = JsonSerializer.Deserialize<string>(ref reader, options);
-							error.Reason = value;
-							continue;
-						}
-
-						additional ??= new Dictionary<string, object>();
-						var key = reader.GetString();
-						var additionaValue = JsonSerializer.Deserialize<object>(ref reader, options);
-						additional.Add(key, additionaValue);
+						var value = JsonSerializer.Deserialize<IReadOnlyCollection<ErrorCause>>(ref reader, options);
+						error.RootCause = value;
+						continue;
+					}
+
+					if (reader.ValueTextEquals("caused_by"))
+					{
+						var value = JsonSerializer.Deserialize<ErrorCause>(ref reader, options);
+						error.CausedBy = value;
+						continue;
+					}
+
+					//if (reader.ValueTextEquals("suppressed"))
+					//{
+					//	var value = JsonSerializer.Deserialize<IReadOnlyCollection<ErrorCause>>(ref reader, options);
+					//	error.TODO = value;
+					//	continue;
+					//}
+
+					if (reader.ValueTextEquals("headers"))
+					{
+						var value = JsonSerializer.Deserialize<IReadOnlyDictionary<string, string>>(ref reader, options);
+						error.Headers = value;
+						continue;
+					}
+
+					if (reader.ValueTextEquals("stack_trace"))
+					{
+						var value = JsonSerializer.Deserialize<string>(ref reader, options);
+						error.StackTrace = value;
+						continue;
+					}
+
+					if (reader.ValueTextEquals("type"))
+					{
+						var value = JsonSerializer.Deserialize<string>(ref reader, options);
+						error.Type = value;
+						continue;
+					}
+
+					if (reader.ValueTextEquals("index"))
+					{
+						var value = JsonSerializer.Deserialize<string>(ref reader, options);
+						error.Index = value;
+						continue;
 					}
-				}
 
-				if (additional is not null)
-					error.AdditionalProperties = additional;
+					if (reader.ValueTextEquals("index_uuid"))
+					{
+						var value = JsonSerializer.Deserialize<string>(ref reader, options);
+						error.IndexUUID = value;
+						continue;
+					}
 
-				return error;
+					if (reader.ValueTextEquals("reason"))
+					{
+						var value = JsonSerializer.Deserialize<string>(ref reader, options);
+						error.Reason = value;
+						continue;
+					}
+
+					additional ??= new Dictionary<string, object>();
+					var key = reader.GetString();
+					var additionaValue = JsonSerializer.Deserialize<object>(ref reader, options);
+					additional.Add(key, additionaValue);
+				}
 			}
 
-			throw new JsonException("Could not deserialise the error response.");
+			if (additional is not null)
+				error.AdditionalProperties = additional;
+
+			return error;
 		}
 
-		public override void Write(Utf8JsonWriter writer, Error value, JsonSerializerOptions options) => throw new NotImplementedException();
+		throw new JsonException("Could not deserialise the error response.");
 	}
+
+	public override void Write(Utf8JsonWriter writer, Error value, JsonSerializerOptions options) => throw new NotImplementedException();
 }
diff --git a/src/Elastic.Transport/Products/Elasticsearch/Failures/ErrorCause.cs b/src/Elastic.Transport/Products/Elasticsearch/Failures/ErrorCause.cs
index 7d9eda3..89c07a9 100644
--- a/src/Elastic.Transport/Products/Elasticsearch/Failures/ErrorCause.cs
+++ b/src/Elastic.Transport/Products/Elasticsearch/Failures/ErrorCause.cs
@@ -7,85 +7,84 @@
 using System.Runtime.Serialization;
 using System.Text.Json.Serialization;
 
-namespace Elastic.Transport.Products.Elasticsearch
+namespace Elastic.Transport.Products.Elasticsearch;
+
+/// <summary> Represents an Elasticsearch server exception. </summary>
+[DataContract]
+[JsonConverter(typeof(ErrorCauseConverter))]
+public class ErrorCause
 {
-	/// <summary> Represents an Elasticsearch server exception. </summary>
-	[DataContract]
-	[JsonConverter(typeof(ErrorCauseConverter))]
-	public class ErrorCause
-	{
-		//private static readonly IReadOnlyCollection<string> DefaultCollection =
-		//	new ReadOnlyCollection<string>(new string[0]);
-
-		private static readonly IReadOnlyDictionary<string, object> DefaultDictionary =
-			new ReadOnlyDictionary<string, object>(new Dictionary<string, object>());
-
-		//private static readonly IReadOnlyCollection<ShardFailure> DefaultFailedShards =
-		//	new ReadOnlyCollection<ShardFailure>(new ShardFailure[0]);
-
-		/// <summary>
-		/// Additional properties related to the error cause. Contains properties that
-		/// are not explicitly mapped on <see cref="ErrorCause" />
-		/// </summary>
-		public IReadOnlyDictionary<string, object> AdditionalProperties { get; set; } = DefaultDictionary;
-
-		/// <summary> The name of the Elasticsearch server exception that was thrown </summary>
-		public string Type { get; set; }
-
-		/// <summary>
-		/// If stacktrace was requested this holds the java stack trace as it occurred on the server
-		/// </summary>
-		[JsonPropertyName("stack_trace")]
-		public string StackTrace { get; set; }
-
-		/// <summary>
-		/// The exception message of the exception that was thrown on the server causing the request to fail
-		/// </summary>
-		public string Reason { get; set; }
+	//private static readonly IReadOnlyCollection<string> DefaultCollection =
+	//	new ReadOnlyCollection<string>(new string[0]);
+
+	private static readonly IReadOnlyDictionary<string, object> DefaultDictionary =
+		new ReadOnlyDictionary<string, object>(new Dictionary<string, object>());
+
+	//private static readonly IReadOnlyCollection<ShardFailure> DefaultFailedShards =
+	//	new ReadOnlyCollection<ShardFailure>(new ShardFailure[0]);
+
+	/// <summary>
+	/// Additional properties related to the error cause. Contains properties that
+	/// are not explicitly mapped on <see cref="ErrorCause" />
+	/// </summary>
+	public IReadOnlyDictionary<string, object> AdditionalProperties { get; internal set; } = DefaultDictionary;
+
+	/// <summary> The name of the Elasticsearch server exception that was thrown </summary>
+	public string Type { get; internal set; }
+
+	/// <summary>
+	/// If stacktrace was requested this holds the java stack trace as it occurred on the server
+	/// </summary>
+	[JsonPropertyName("stack_trace")]
+	public string StackTrace { get; internal set; }
+
+	/// <summary>
+	/// The exception message of the exception that was thrown on the server causing the request to fail
+	/// </summary>
+	public string Reason { get; internal set; }
 
 // The following are all very specific to individual failures
 // Seeking to clean this up within Elasticsearch itself: https://github.com/elastic/elasticsearch/issues/27672
 #pragma warning disable 1591
-		//public long? BytesLimit { get; set; }
+	//public long? BytesLimit { get; set; }
 
-		//public long? BytesWanted { get; set; }
+	//public long? BytesWanted { get; set; }
 
-		public ErrorCause CausedBy { get; set; }
+	public ErrorCause CausedBy { get; internal set; }
 
-		//public int? Column { get; set; }
+	//public int? Column { get; set; }
 
-		//public IReadOnlyCollection<ShardFailure> FailedShards { get; set; } = DefaultFailedShards;
+	//public IReadOnlyCollection<ShardFailure> FailedShards { get; set; } = DefaultFailedShards;
 
-		//public bool? Grouped { get; set; }
+	//public bool? Grouped { get; set; }
 
-		public string Index { get; set; }
+	public string Index { get; internal set; }
 
-		public string IndexUUID { get; set; }
+	public string IndexUUID { get; internal set; }
 
-		//public string Language { get; set; }
+	//public string Language { get; set; }
 
-		//public string LicensedExpiredFeature { get; set; }
+	//public string LicensedExpiredFeature { get; set; }
 
-		//public int? Line { get; set; }
+	//public int? Line { get; set; }
 
-		//public string Phase { get; set; }
+	//public string Phase { get; set; }
 
-		//public IReadOnlyCollection<string> ResourceId { get; set; } = DefaultCollection;
+	//public IReadOnlyCollection<string> ResourceId { get; set; } = DefaultCollection;
 
-		//public string ResourceType { get; set; }
+	//public string ResourceType { get; set; }
 
-		//public string Script { get; set; }
+	//public string Script { get; set; }
 
-		//public IReadOnlyCollection<string> ScriptStack { get; set; } = DefaultCollection;
+	//public IReadOnlyCollection<string> ScriptStack { get; set; } = DefaultCollection;
 
-		// TODO: This attribute is supported from 5.8 onward. At the moment Transport depends on that version but is that safe?
-		//[JsonNumberHandling(JsonNumberHandling.AllowReadingFromString)]
-		//public int? Shard { get; set; }
+	// TODO: This attribute is supported from 5.8 onward. At the moment Transport depends on that version but is that safe?
+	//[JsonNumberHandling(JsonNumberHandling.AllowReadingFromString)]
+	//public int? Shard { get; set; }
 #pragma warning restore 1591
 
-		/// <summary> A human readable string representation of the exception returned by Elasticsearch </summary>
-		public override string ToString() => CausedBy == null
-			? $"Type: {Type} Reason: \"{Reason}\""
-			: $"Type: {Type} Reason: \"{Reason}\" CausedBy: \"{CausedBy}\"";
-	}
+	/// <summary> A human readable string representation of the exception returned by Elasticsearch </summary>
+	public override string ToString() => CausedBy == null
+		? $"Type: {Type} Reason: \"{Reason}\""
+		: $"Type: {Type} Reason: \"{Reason}\" CausedBy: \"{CausedBy}\"";
 }
diff --git a/src/Elastic.Transport/Products/Elasticsearch/Failures/ServerError.cs b/src/Elastic.Transport/Products/Elasticsearch/Failures/ServerError.cs
deleted file mode 100644
index 721a805..0000000
--- a/src/Elastic.Transport/Products/Elasticsearch/Failures/ServerError.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System.IO;
-using System.Runtime.Serialization;
-using System.Text;
-using System.Text.Json.Serialization;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Elastic.Transport.Products.Elasticsearch
-{
-	/// <summary> Represents the error response as returned by Elasticsearch. </summary>
-	[DataContract]
-	public class ServerError : ErrorResponse
-	{
-		/// <inheritdoc cref="ServerError"/>
-		public ServerError() { }
-
-		/// <inheritdoc cref="ServerError"/>
-		public ServerError(Error error, int? statusCode)
-		{
-			Error = error;
-			Status = statusCode.GetValueOrDefault(-1);
-		}
-
-		/// <summary> an <see cref="Error"/> object that represents the server exception that occurred</summary>
-		[DataMember(Name = "error")]
-		[JsonPropertyName("error")]
-		public Error Error { get; set; }
-
-		/// <summary> The HTTP status code returned from the server </summary>
-		[DataMember(Name = "status")]
-		[JsonPropertyName("status")]
-		public int Status { get; set; } = -1;
-
-		/// <summary>
-		/// Try and create an instance of <see cref="ServerError"/> from <paramref name="stream"/>
-		/// </summary>
-		/// <returns>Whether a an instance of <see cref="ServerError"/> was created successfully</returns>
-		public static bool TryCreate(Stream stream, out ServerError serverError)
-		{
-			try
-			{
-				serverError = Create(stream);
-				return serverError != null;
-			}
-			catch
-			{
-				serverError = null;
-				return false;
-			}
-		}
-
-		/// <summary>
-		/// Use the clients default <see cref="LowLevelRequestResponseSerializer"/> to create an instance
-		/// of <see cref="ServerError"/> from <paramref name="stream"/>
-		/// </summary>
-		public static ServerError Create(Stream stream) =>
-			LowLevelRequestResponseSerializer.Instance.Deserialize<ServerError>(stream);
-
-		// ReSharper disable once UnusedMember.Global
-		/// <inheritdoc cref="Create"/>
-		public static ValueTask<ServerError> CreateAsync(Stream stream, CancellationToken token = default) =>
-			LowLevelRequestResponseSerializer.Instance.DeserializeAsync<ServerError>(stream, token);
-
-		/// <summary> A human readable string representation of the server error returned by Elasticsearch </summary>
-		public override string ToString()
-		{
-			var sb = new StringBuilder();
-			sb.Append($"ServerError: {Status}");
-			if (Error != null)
-				sb.Append(Error);
-			return sb.ToString();
-		}
-
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <returns></returns>
-		public override bool HasError() => Status > 0 && Error is not null;
-	}
-}
diff --git a/src/Elastic.Transport/Products/Elasticsearch/Failures/ShardFailure.cs b/src/Elastic.Transport/Products/Elasticsearch/Failures/ShardFailure.cs
index 5722954..9f4b39b 100644
--- a/src/Elastic.Transport/Products/Elasticsearch/Failures/ShardFailure.cs
+++ b/src/Elastic.Transport/Products/Elasticsearch/Failures/ShardFailure.cs
@@ -5,33 +5,32 @@
 using System.Runtime.Serialization;
 using System.Text.Json.Serialization;
 
-namespace Elastic.Transport.Products.Elasticsearch
+namespace Elastic.Transport.Products.Elasticsearch;
+
+/// <summary> Represents a failure that occurred on a shard involved in the request </summary>
+[DataContract]
+public sealed class ShardFailure
 {
-	/// <summary> Represents a failure that occurred on a shard involved in the request </summary>
-	[DataContract]
-	public class ShardFailure
-	{
-		/// <summary> This index this shard belongs to </summary>
-		[JsonPropertyName("index")]
-		public string Index { get; set; }
+	/// <summary> This index this shard belongs to </summary>
+	[JsonPropertyName("index")]
+	public string Index { get; set; }
 
-		/// <summary> The node the shard is currently allocated on</summary>
-		[JsonPropertyName("node")]
-		public string Node { get; set; }
+	/// <summary> The node the shard is currently allocated on</summary>
+	[JsonPropertyName("node")]
+	public string Node { get; set; }
 
-		/// <summary>
-		/// The java exception that caused the shard to fail
-		/// </summary>
-		[JsonPropertyName("reason")]
-		public ErrorCause Reason { get; set; }
+	/// <summary>
+	/// The java exception that caused the shard to fail
+	/// </summary>
+	[JsonPropertyName("reason")]
+	public ErrorCause Reason { get; set; }
 
-		/// <summary> The shard number that failed </summary>
-		[JsonPropertyName("shard")]
-		[JsonNumberHandling(JsonNumberHandling.AllowReadingFromString)]
-		public int? Shard { get; set; }
+	/// <summary> The shard number that failed </summary>
+	[JsonPropertyName("shard")]
+	[JsonNumberHandling(JsonNumberHandling.AllowReadingFromString)]
+	public int? Shard { get; set; }
 
-		/// <summary> The status of the shard when the exception occured</summary>
-		[JsonPropertyName("status")]
-		public string Status { get; set; }
-	}
+	/// <summary> The status of the shard when the exception occured</summary>
+	[JsonPropertyName("status")]
+	public string Status { get; set; }
 }
diff --git a/src/Elastic.Transport/Products/Elasticsearch/IElasticsearchResponse.cs b/src/Elastic.Transport/Products/Elasticsearch/IElasticsearchResponse.cs
deleted file mode 100644
index 74fd9a5..0000000
--- a/src/Elastic.Transport/Products/Elasticsearch/IElasticsearchResponse.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System;
-using System.Text.Json.Serialization;
-
-namespace Elastic.Transport.Products.Elasticsearch
-{
-	/// <summary>
-	/// A response from Elasticsearch
-	/// </summary>
-	public interface IElasticsearchResponse : ITransportResponse
-	{
-		/// <summary>
-		/// A lazily computed, human readable string representation of what happened during a request for both successful and
-		/// failed requests. Useful whilst developing or to log when <see cref="IsValid" /> is false on responses.
-		/// </summary>
-		[JsonIgnore]
-		string DebugInformation { get; }
-
-		/// <summary>
-		/// Checks if a response is functionally valid or not.
-		/// This is a Elastic.Clients.Elasticsearch abstraction to have a single property to check whether there was something wrong with a request.
-		/// <para>
-		/// For instance, an Elasticsearch bulk response always returns 200 and individual bulk items may fail,
-		/// <see cref="IsValid" /> will be false in that case.
-		/// </para>
-		/// <para>
-		/// You can also configure the client to always throw an <see cref="TransportException" /> using
-		/// <see cref="ITransportConfiguration.ThrowExceptions" /> if the response is not valid
-		/// </para>
-		/// </summary>
-		[JsonIgnore]
-		bool IsValid { get; }
-
-		/// <summary>
-		/// If the request resulted in an exception on the client side this will hold the exception that was thrown.
-		/// <para>
-		/// This property is a shortcut to <see cref="ITransportResponse.ApiCall" />'s
-		/// <see cref="IApiCallDetails.OriginalException" /> and
-		/// is possibly set when <see cref="IsValid" /> is false depending on the cause of the error
-		/// </para>
-		/// <para>
-		/// You can also configure the client to always throw an <see cref="TransportException" /> using
-		/// <see cref="ITransportConfiguration.ThrowExceptions" /> if the response is not valid
-		/// </para>
-		/// </summary>
-		[JsonIgnore]
-		Exception? OriginalException { get; }
-	}
-}
diff --git a/src/Elastic.Transport/Products/Elasticsearch/Sniff/NodeInfo.cs b/src/Elastic.Transport/Products/Elasticsearch/Sniff/NodeInfo.cs
new file mode 100644
index 0000000..d795a04
--- /dev/null
+++ b/src/Elastic.Transport/Products/Elasticsearch/Sniff/NodeInfo.cs
@@ -0,0 +1,42 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System;
+using System.Collections.Generic;
+using System.Text.Json;
+
+namespace Elastic.Transport.Products.Elasticsearch;
+
+internal sealed class NodeInfo
+{
+	public string build_hash { get; set; }
+	public string host { get; set; }
+	public NodeInfoHttp http { get; set; }
+	public string ip { get; set; }
+	public string name { get; set; }
+	public IList<string> roles { get; set; }
+	public IDictionary<string, object> settings { get; set; }
+	public string transport_address { get; set; }
+	public string version { get; set; }
+	internal bool HoldsData => roles?.Contains("data") ?? false;
+
+	internal bool HttpEnabled
+	{
+		get
+		{
+			if (settings != null && settings.TryGetValue("http.enabled", out var httpEnabled))
+			{
+				if (httpEnabled is JsonElement e)
+					return e.GetBoolean();
+				return Convert.ToBoolean(httpEnabled);
+			}
+
+			return http != null;
+		}
+	}
+
+	internal bool IngestEnabled => roles?.Contains("ingest") ?? false;
+
+	internal bool MasterEligible => roles?.Contains("master") ?? false;
+}
diff --git a/src/Elastic.Transport/Products/Elasticsearch/Sniff/NodeInfoHttp.cs b/src/Elastic.Transport/Products/Elasticsearch/Sniff/NodeInfoHttp.cs
new file mode 100644
index 0000000..3c8519a
--- /dev/null
+++ b/src/Elastic.Transport/Products/Elasticsearch/Sniff/NodeInfoHttp.cs
@@ -0,0 +1,13 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System.Collections.Generic;
+
+namespace Elastic.Transport.Products.Elasticsearch;
+
+internal sealed class NodeInfoHttp
+{
+	public IList<string> bound_address { get; set; }
+	public string publish_address { get; set; }
+}
diff --git a/src/Elastic.Transport/Products/Elasticsearch/Sniff/SniffParser.cs b/src/Elastic.Transport/Products/Elasticsearch/Sniff/SniffParser.cs
new file mode 100644
index 0000000..268b245
--- /dev/null
+++ b/src/Elastic.Transport/Products/Elasticsearch/Sniff/SniffParser.cs
@@ -0,0 +1,42 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System;
+using System.Text.RegularExpressions;
+using Elastic.Transport.Extensions;
+
+namespace Elastic.Transport.Products.Elasticsearch;
+
+/// <summary>
+/// Elasticsearch returns addresses in the form of
+/// <para>[fqdn]/ip:port number</para>
+/// This helper parses it to <see cref="Uri"/>
+/// </summary>
+public static class SniffParser
+{
+	/// <summary> A regular expression that captures <c>fqdn</c>, <c>ip</c> and <c>por</c> </summary>
+	public static Regex AddressRegex { get; } =
+		new Regex(@"^((?<fqdn>[^/]+)/)?(?<ip>[^:]+|\[[\da-fA-F:\.]+\]):(?<port>\d+)$");
+
+	/// <summary>
+	/// Elasticsearch returns addresses in the form of
+	/// <para>[fqdn]/ip:port number</para>
+	/// This helper parses it to <see cref="Uri"/>
+	/// </summary>
+	public static Uri ParseToUri(string boundAddress, bool forceHttp)
+	{
+		if (boundAddress == null) throw new ArgumentNullException(nameof(boundAddress));
+
+		var suffix = forceHttp ? "s" : string.Empty;
+		var match = AddressRegex.Match(boundAddress);
+		if (!match.Success) throw new Exception($"Can not parse bound_address: {boundAddress} to Uri");
+
+		var fqdn = match.Groups["fqdn"].Value.Trim();
+		var ip = match.Groups["ip"].Value.Trim();
+		var port = match.Groups["port"].Value.Trim();
+		var host = !fqdn.IsNullOrEmpty() ? fqdn : ip;
+
+		return new Uri($"http{suffix}://{host}:{port}");
+	}
+}
diff --git a/src/Elastic.Transport/Products/Elasticsearch/Sniff/SniffResponse.cs b/src/Elastic.Transport/Products/Elasticsearch/Sniff/SniffResponse.cs
index 794c7e4..e5acae7 100644
--- a/src/Elastic.Transport/Products/Elasticsearch/Sniff/SniffResponse.cs
+++ b/src/Elastic.Transport/Products/Elasticsearch/Sniff/SniffResponse.cs
@@ -2,124 +2,47 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
-using System.Text.Json;
-using System.Text.RegularExpressions;
-using Elastic.Transport.Extensions;
 using static Elastic.Transport.Products.Elasticsearch.ElasticsearchNodeFeatures;
 
-namespace Elastic.Transport.Products.Elasticsearch
-{
-	/// <summary>
-	/// Elasticsearch returns addresses in the form of
-	/// <para>[fqdn]/ip:port number</para>
-	/// This helper parses it to <see cref="Uri"/>
-	/// </summary>
-	public static class SniffParser
-	{
-		/// <summary> A regular expression that captures <c>fqdn</c>, <c>ip</c> and <c>por</c> </summary>
-		public static Regex AddressRegex { get; } =
-			new Regex(@"^((?<fqdn>[^/]+)/)?(?<ip>[^:]+|\[[\da-fA-F:\.]+\]):(?<port>\d+)$");
-
-		/// <summary>
-		/// Elasticsearch returns addresses in the form of
-		/// <para>[fqdn]/ip:port number</para>
-		/// This helper parses it to <see cref="Uri"/>
-		/// </summary>
-		public static Uri ParseToUri(string boundAddress, bool forceHttp)
-		{
-			if (boundAddress == null) throw new ArgumentNullException(nameof(boundAddress));
+namespace Elastic.Transport.Products.Elasticsearch;
 
-			var suffix = forceHttp ? "s" : string.Empty;
-			var match = AddressRegex.Match(boundAddress);
-			if (!match.Success) throw new Exception($"Can not parse bound_address: {boundAddress} to Uri");
-
-			var fqdn = match.Groups["fqdn"].Value.Trim();
-			var ip = match.Groups["ip"].Value.Trim();
-			var port = match.Groups["port"].Value.Trim();
-			var host = !fqdn.IsNullOrEmpty() ? fqdn : ip;
-
-			return new Uri($"http{suffix}://{host}:{port}");
-		}
-	}
-
-	internal class SniffResponse : TransportResponse
-	{
-		// ReSharper disable InconsistentNaming
-		public string cluster_name { get; set; }
-
-		public Dictionary<string, NodeInfo> nodes { get; set; }
-
-		public IEnumerable<Node> ToNodes(bool forceHttp = false)
-		{
-			foreach (var kv in nodes.Where(n => n.Value.HttpEnabled))
-			{
-				var info = kv.Value;
-				var httpEndpoint = info.http?.publish_address;
-				if (string.IsNullOrWhiteSpace(httpEndpoint))
-					httpEndpoint = kv.Value.http?.bound_address.FirstOrDefault();
-				if (string.IsNullOrWhiteSpace(httpEndpoint))
-					continue;
-
-				var uri = SniffParser.ParseToUri(httpEndpoint, forceHttp);
-				var features = new List<string>();
-				if (info.MasterEligible)
-					features.Add(MasterEligible);
-				if (info.HoldsData)
-					features.Add(HoldsData);
-				if (info.IngestEnabled)
-					features.Add(IngestEnabled);
-				if (info.HttpEnabled)
-					features.Add(HttpEnabled);
+internal sealed class SniffResponse : TransportResponse
+{
+	// ReSharper disable InconsistentNaming
+	public string cluster_name { get; set; }
 
-				var node = new Node(uri, features)
-				{
-					Name = info.name, Id = kv.Key, Settings = new ReadOnlyDictionary<string, object>(info.settings)
-				};
-				yield return node;
-			}
-		}
-	}
+	public Dictionary<string, NodeInfo> nodes { get; set; }
 
-	internal class NodeInfo
+	public IEnumerable<Node> ToNodes(bool forceHttp = false)
 	{
-		public string build_hash { get; set; }
-		public string host { get; set; }
-		public NodeInfoHttp http { get; set; }
-		public string ip { get; set; }
-		public string name { get; set; }
-		public IList<string> roles { get; set; }
-		public IDictionary<string, object> settings { get; set; }
-		public string transport_address { get; set; }
-		public string version { get; set; }
-		internal bool HoldsData => roles?.Contains("data") ?? false;
-
-		internal bool HttpEnabled
+		foreach (var kv in nodes.Where(n => n.Value.HttpEnabled))
 		{
-			get
+			var info = kv.Value;
+			var httpEndpoint = info.http?.publish_address;
+			if (string.IsNullOrWhiteSpace(httpEndpoint))
+				httpEndpoint = kv.Value.http?.bound_address.FirstOrDefault();
+			if (string.IsNullOrWhiteSpace(httpEndpoint))
+				continue;
+
+			var uri = SniffParser.ParseToUri(httpEndpoint, forceHttp);
+			var features = new List<string>();
+			if (info.MasterEligible)
+				features.Add(MasterEligible);
+			if (info.HoldsData)
+				features.Add(HoldsData);
+			if (info.IngestEnabled)
+				features.Add(IngestEnabled);
+			if (info.HttpEnabled)
+				features.Add(HttpEnabled);
+
+			var node = new Node(uri, features)
 			{
-				if (settings != null && settings.TryGetValue("http.enabled", out var httpEnabled))
-				{
-					if (httpEnabled is JsonElement e)
-						return e.GetBoolean();
-					return Convert.ToBoolean(httpEnabled);
-				}
-
-				return http != null;
-			}
+				Name = info.name, Id = kv.Key, Settings = new ReadOnlyDictionary<string, object>(info.settings)
+			};
+			yield return node;
 		}
-
-		internal bool IngestEnabled => roles?.Contains("ingest") ?? false;
-
-		internal bool MasterEligible => roles?.Contains("master") ?? false;
-	}
-
-	internal class NodeInfoHttp
-	{
-		public IList<string> bound_address { get; set; }
-		public string publish_address { get; set; }
 	}
 }
diff --git a/src/Elastic.Transport/Products/IProductRegistration.cs b/src/Elastic.Transport/Products/IProductRegistration.cs
deleted file mode 100644
index c33386b..0000000
--- a/src/Elastic.Transport/Products/IProductRegistration.cs
+++ /dev/null
@@ -1,113 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace Elastic.Transport.Products
-{
-	/// <summary>
-	/// When <see cref="ITransport.Request{TResponse}"/> interfaces with a product some parts are
-	/// bespoke for each product. This interface defines the contract products will have to implement in order to fill
-	/// in these bespoke parts.
-	/// <para>The expectation is that unless you instantiate <see cref="Transport{TConnectionSettings}"/>
-	/// directly clients that utilize transport will fill in this dependency
-	/// </para>
-	/// <para>
-	/// If you do want to use a bare-bones <see cref="Transport{TConnectionSettings}"/> you can use
-	/// <see cref="ProductRegistration.Default"/>
-	/// </para>
-	/// </summary>
-	public interface IProductRegistration
-	{
-		/// <summary>
-		/// The name of the current product utilizing <see cref="ITransport{TConnectionSettings}"/>
-		/// <para>This name makes its way into the transport diagnostics sources and the default user agent string</para>
-		/// </summary>
-		string Name { get; }
-
-		/// <summary>
-		/// Whether the product <see cref="ITransport{TConnectionSettings}"/> will call out to supports ping endpoints
-		/// </summary>
-		bool SupportsPing { get; }
-
-		/// <summary>
-		/// Whether the product <see cref="ITransport{TConnectionSettings}"/> will call out to supports sniff endpoints that return
-		/// information about available nodes
-		/// </summary>
-		bool SupportsSniff { get; }
-
-		/// <summary>
-		/// The set of headers to parse from all requests by default. These can be added to any consumer specific requirements.
-		/// </summary>
-		HeadersList ResponseHeadersToParse { get; }
-
-		/// <summary>
-		/// Create an instance of <see cref="RequestData"/> that describes where and how to ping see <paramref name="node" />
-		/// <para>All the parameters of this method correspond with <see cref="RequestData"/>'s constructor</para>
-		/// </summary>
-		RequestData CreatePingRequestData(Node node, RequestConfiguration requestConfiguration, ITransportConfiguration global, IMemoryStreamFactory memoryStreamFactory);
-
-		/// <summary>
-		/// Provide an implementation that performs the ping directly using <see cref="ITransportClient.RequestAsync{TResponse}"/> and the <see cref="RequestData"/>
-		/// return by <see cref="CreatePingRequestData"/>
-		/// </summary>
-		Task<IApiCallDetails> PingAsync(ITransportClient connection, RequestData pingData, CancellationToken cancellationToken);
-
-		/// <summary>
-		/// Provide an implementation that performs the ping directly using <see cref="ITransportClient.Request{TResponse}"/> and the <see cref="RequestData"/>
-		/// return by <see cref="CreatePingRequestData"/>
-		/// </summary>
-		IApiCallDetails Ping(ITransportClient connection, RequestData pingData);
-
-		/// <summary>
-		/// Create an instance of <see cref="RequestData"/> that describes where and how to sniff the cluster using <paramref name="node" />
-		/// <para>All the parameters of this method correspond with <see cref="RequestData"/>'s constructor</para>
-		/// </summary>
-		RequestData CreateSniffRequestData(Node node, IRequestConfiguration requestConfiguration, ITransportConfiguration settings,
-			IMemoryStreamFactory memoryStreamFactory
-		);
-
-		/// <summary>
-		/// Provide an implementation that performs the sniff directly using <see cref="ITransportClient.Request{TResponse}"/> and the <see cref="RequestData"/>
-		/// return by <see cref="CreateSniffRequestData"/>
-		/// </summary>
-		Task<Tuple<IApiCallDetails, IReadOnlyCollection<Node>>> SniffAsync(ITransportClient connection, bool forceSsl, RequestData requestData, CancellationToken cancellationToken);
-
-		/// <summary>
-		/// Provide an implementation that performs the sniff directly using <see cref="ITransportClient.Request{TResponse}"/> and the <see cref="RequestData"/>
-		/// return by <see cref="CreateSniffRequestData"/>
-		/// </summary>
-		Tuple<IApiCallDetails, IReadOnlyCollection<Node>> Sniff(ITransportClient connection, bool forceSsl, RequestData requestData);
-
-		/// <summary> Allows certain nodes to be queried first to obtain sniffing information </summary>
-		int SniffOrder(Node node);
-
-		/// <summary> Predicate indicating a node is allowed to be used for API calls</summary>
-		/// <param name="node">The node to inspect</param>
-		/// <returns>bool, true if node should allows API calls</returns>
-		bool NodePredicate(Node node);
-
-		/// <summary>
-		/// Used by <see cref="ResponseBuilder"/> to determine if it needs to return true or false for
-		/// <see cref="IApiCallDetails.Success"/>
-		/// </summary>
-		bool HttpStatusCodeClassifier(HttpMethod method, int statusCode);
-
-		/// <summary> Try to obtain a server error from the response, this is used for debugging and exception messages </summary>
-		bool TryGetServerErrorReason<TResponse>(TResponse response, out string reason) where TResponse : ITransportResponse;
-
-		/// <summary>
-		/// TODO
-		/// </summary>
-		MetaHeaderProvider MetaHeaderProvider { get; }
-
-		/// <summary>
-		/// TODO
-		/// </summary>
-		ResponseBuilder ResponseBuilder { get; }
-	}
-}
diff --git a/src/Elastic.Transport/Products/ProductRegistration.cs b/src/Elastic.Transport/Products/ProductRegistration.cs
new file mode 100644
index 0000000..27e397f
--- /dev/null
+++ b/src/Elastic.Transport/Products/ProductRegistration.cs
@@ -0,0 +1,111 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Elastic.Transport.Products;
+
+/// <summary>
+/// When <see cref="HttpTransport.Request{TResponse}"/> interfaces with a product some parts are
+/// bespoke for each product. This interface defines the contract products will have to implement in order to fill
+/// in these bespoke parts.
+/// <para>The expectation is that unless you instantiate <see cref="DefaultHttpTransport{TConnectionSettings}"/>
+/// directly clients that utilize transport will fill in this dependency
+/// </para>
+/// <para>
+/// If you do want to use a bare-bones <see cref="DefaultHttpTransport{TConnectionSettings}"/> you can use
+/// <see cref="DefaultProductRegistration.Default"/>
+/// </para>
+/// </summary>
+public abstract class ProductRegistration
+{
+	/// <summary>
+	/// The name of the current product utilizing <see cref="HttpTransport{TConnectionSettings}"/>
+	/// <para>This name makes its way into the transport diagnostics sources and the default user agent string</para>
+	/// </summary>
+	public abstract string Name { get; }
+
+	/// <summary>
+	/// Whether the product <see cref="HttpTransport{TConnectionSettings}"/> will call out to supports ping endpoints
+	/// </summary>
+	public abstract bool SupportsPing { get; }
+
+	/// <summary>
+	/// Whether the product <see cref="HttpTransport{TConnectionSettings}"/> will call out to supports sniff endpoints that return
+	/// information about available nodes
+	/// </summary>
+	public abstract bool SupportsSniff { get; }
+
+	/// <summary>
+	/// The set of headers to parse from all requests by default. These can be added to any consumer specific requirements.
+	/// </summary>
+	public abstract HeadersList ResponseHeadersToParse { get; }
+
+	/// <summary>
+	/// Create an instance of <see cref="RequestData"/> that describes where and how to ping see <paramref name="node" />
+	/// <para>All the parameters of this method correspond with <see cref="RequestData"/>'s constructor</para>
+	/// </summary>
+	public abstract RequestData CreatePingRequestData(Node node, RequestConfiguration requestConfiguration, ITransportConfiguration global, MemoryStreamFactory memoryStreamFactory);
+
+	/// <summary>
+	/// Provide an implementation that performs the ping directly using <see cref="TransportClient.RequestAsync{TResponse}"/> and the <see cref="RequestData"/>
+	/// return by <see cref="CreatePingRequestData"/>
+	/// </summary>
+	public abstract Task<TransportResponse> PingAsync(TransportClient connection, RequestData pingData, CancellationToken cancellationToken);
+
+	/// <summary>
+	/// Provide an implementation that performs the ping directly using <see cref="TransportClient.Request{TResponse}"/> and the <see cref="RequestData"/>
+	/// return by <see cref="CreatePingRequestData"/>
+	/// </summary>
+	public abstract TransportResponse Ping(TransportClient connection, RequestData pingData);
+
+	/// <summary>
+	/// Create an instance of <see cref="RequestData"/> that describes where and how to sniff the cluster using <paramref name="node" />
+	/// <para>All the parameters of this method correspond with <see cref="RequestData"/>'s constructor</para>
+	/// </summary>
+	public abstract RequestData CreateSniffRequestData(Node node, IRequestConfiguration requestConfiguration, ITransportConfiguration settings,
+		MemoryStreamFactory memoryStreamFactory);
+
+	/// <summary>
+	/// Provide an implementation that performs the sniff directly using <see cref="TransportClient.Request{TResponse}"/> and the <see cref="RequestData"/>
+	/// return by <see cref="CreateSniffRequestData"/>
+	/// </summary>
+	public abstract Task<Tuple<TransportResponse, IReadOnlyCollection<Node>>> SniffAsync(TransportClient connection, bool forceSsl, RequestData requestData, CancellationToken cancellationToken);
+
+	/// <summary>
+	/// Provide an implementation that performs the sniff directly using <see cref="TransportClient.Request{TResponse}"/> and the <see cref="RequestData"/>
+	/// return by <see cref="CreateSniffRequestData"/>
+	/// </summary>
+	public abstract Tuple<TransportResponse, IReadOnlyCollection<Node>> Sniff(TransportClient connection, bool forceSsl, RequestData requestData);
+
+	/// <summary> Allows certain nodes to be queried first to obtain sniffing information </summary>
+	public abstract int SniffOrder(Node node);
+
+	/// <summary> Predicate indicating a node is allowed to be used for API calls</summary>
+	/// <param name="node">The node to inspect</param>
+	/// <returns>bool, true if node should allows API calls</returns>
+	public abstract bool NodePredicate(Node node);
+
+	/// <summary>
+	/// Used by <see cref="ResponseBuilder"/> to determine if it needs to return true or false for
+	/// <see cref="ApiCallDetails.Success"/>
+	/// </summary>
+	public abstract bool HttpStatusCodeClassifier(HttpMethod method, int statusCode);
+
+	/// <summary> Try to obtain a server error from the response, this is used for debugging and exception messages </summary>
+	public abstract bool TryGetServerErrorReason<TResponse>(TResponse response, out string reason) where TResponse : TransportResponse;
+
+	/// <summary>
+	/// TODO
+	/// </summary>
+	public abstract MetaHeaderProvider MetaHeaderProvider { get; }
+
+	/// <summary>
+	/// TODO
+	/// </summary>
+	public abstract ResponseBuilder ResponseBuilder { get; }
+}
diff --git a/src/Elastic.Transport/Requests/Body/PostData.ByteArray.cs b/src/Elastic.Transport/Requests/Body/PostData.ByteArray.cs
index 6493d20..9843d80 100644
--- a/src/Elastic.Transport/Requests/Body/PostData.ByteArray.cs
+++ b/src/Elastic.Transport/Requests/Body/PostData.ByteArray.cs
@@ -6,53 +6,52 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+public abstract partial class PostData
 {
-	public abstract partial class PostData
-	{
-		/// <summary>
-		/// Create a <see cref="PostData"/> instance that will write <paramref name="bytes"/> to the output <see cref="Stream"/>
-		/// </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		public static PostData Bytes(byte[] bytes) => new PostDataByteArray(bytes);
+	/// <summary>
+	/// Create a <see cref="PostData"/> instance that will write <paramref name="bytes"/> to the output <see cref="Stream"/>
+	/// </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	public static PostData Bytes(byte[] bytes) => new PostDataByteArray(bytes);
 
-		private class PostDataByteArray : PostData
+	private class PostDataByteArray : PostData
+	{
+		protected internal PostDataByteArray(byte[] item)
 		{
-			protected internal PostDataByteArray(byte[] item)
-			{
-				WrittenBytes = item;
-				Type = PostType.ByteArray;
-			}
+			WrittenBytes = item;
+			Type = PostType.ByteArray;
+		}
 
-			public override void Write(Stream writableStream, ITransportConfiguration settings)
-			{
-				if (WrittenBytes == null) return;
+		public override void Write(Stream writableStream, ITransportConfiguration settings)
+		{
+			if (WrittenBytes == null) return;
 
-				var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
+			var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
 
-				if (!disableDirectStreaming)
-					stream.Write(WrittenBytes, 0, WrittenBytes.Length);
-				else
-					buffer = settings.MemoryStreamFactory.Create(WrittenBytes);
+			if (!disableDirectStreaming)
+				stream.Write(WrittenBytes, 0, WrittenBytes.Length);
+			else
+				buffer = settings.MemoryStreamFactory.Create(WrittenBytes);
 
-				FinishStream(writableStream, buffer, settings);
-			}
+			FinishStream(writableStream, buffer, settings);
+		}
 
-			public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
-				CancellationToken cancellationToken)
-			{
-				if (WrittenBytes == null) return;
+		public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
+			CancellationToken cancellationToken)
+		{
+			if (WrittenBytes == null) return;
 
-				var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
+			var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
 
-				if (!disableDirectStreaming)
-					await stream.WriteAsync(WrittenBytes, 0, WrittenBytes.Length, cancellationToken)
-						.ConfigureAwait(false);
-				else
-					buffer = settings.MemoryStreamFactory.Create(WrittenBytes);
+			if (!disableDirectStreaming)
+				await stream.WriteAsync(WrittenBytes, 0, WrittenBytes.Length, cancellationToken)
+					.ConfigureAwait(false);
+			else
+				buffer = settings.MemoryStreamFactory.Create(WrittenBytes);
 
-				await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
-			}
+			await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Requests/Body/PostData.MultiJson.cs b/src/Elastic.Transport/Requests/Body/PostData.MultiJson.cs
index ea07004..6dd3341 100644
--- a/src/Elastic.Transport/Requests/Body/PostData.MultiJson.cs
+++ b/src/Elastic.Transport/Requests/Body/PostData.MultiJson.cs
@@ -9,149 +9,148 @@
 using System.Threading.Tasks;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+public abstract partial class PostData
 {
-	public abstract partial class PostData
+	/// <summary>
+	/// Create a <see cref="PostData"/> instance that will write the <paramref name="listOfString"/> as multiline/ndjson.
+	/// </summary>
+	public static PostData MultiJson(IEnumerable<string> listOfString) =>
+		new PostDataMultiJson<string>(listOfString);
+
+	/// <summary>
+	/// Create a <see cref="PostData"/> instance that will serialize the <paramref name="listOfSerializables"/> as multiline/ndjson.
+	/// </summary>
+	public static PostData MultiJson<T>(IEnumerable<T> listOfSerializables) =>
+		new PostDataMultiJson<T>(listOfSerializables);
+
+	private class PostDataMultiJson<T> : PostData
 	{
-		/// <summary>
-		/// Create a <see cref="PostData"/> instance that will write the <paramref name="listOfString"/> as multiline/ndjson.
-		/// </summary>
-		public static PostData MultiJson(IEnumerable<string> listOfString) =>
-			new PostDataMultiJson<string>(listOfString);
-
-		/// <summary>
-		/// Create a <see cref="PostData"/> instance that will serialize the <paramref name="listOfSerializables"/> as multiline/ndjson.
-		/// </summary>
-		public static PostData MultiJson<T>(IEnumerable<T> listOfSerializables) =>
-			new PostDataMultiJson<T>(listOfSerializables);
-
-		private class PostDataMultiJson<T> : PostData
+		private readonly IEnumerable<T> _enumerableOfObject;
+		private readonly IEnumerable<string> _enumerableOfStrings;
+
+		protected internal PostDataMultiJson(IEnumerable<string> item)
 		{
-			private readonly IEnumerable<T> _enumerableOfObject;
-			private readonly IEnumerable<string> _enumerableOfStrings;
+			_enumerableOfStrings = item;
+			Type = PostType.EnumerableOfString;
+		}
 
-			protected internal PostDataMultiJson(IEnumerable<string> item)
-			{
-				_enumerableOfStrings = item;
-				Type = PostType.EnumerableOfString;
-			}
+		protected internal PostDataMultiJson(IEnumerable<T> item)
+		{
+			_enumerableOfObject = item;
+			Type = PostType.EnumerableOfObject;
+		}
 
-			protected internal PostDataMultiJson(IEnumerable<T> item)
-			{
-				_enumerableOfObject = item;
-				Type = PostType.EnumerableOfObject;
-			}
+		public override void Write(Stream writableStream, ITransportConfiguration settings)
+		{
+			if (Type != PostType.EnumerableOfObject && Type != PostType.EnumerableOfString)
+				throw new Exception(
+					$"{nameof(PostDataMultiJson<T>)} only does not support {nameof(PostType)}.{Type.GetStringValue()}");
+
+			var stream = InitWrite(writableStream, settings, out var buffer, out _);
 
-			public override void Write(Stream writableStream, ITransportConfiguration settings)
+			switch (Type)
 			{
-				if (Type != PostType.EnumerableOfObject && Type != PostType.EnumerableOfString)
-					throw new Exception(
-						$"{nameof(PostDataMultiJson<T>)} only does not support {nameof(PostType)}.{Type.GetStringValue()}");
+				case PostType.EnumerableOfString:
+				{
+					if (_enumerableOfStrings == null) return;
 
-				var stream = InitWrite(writableStream, settings, out var buffer, out _);
+					using var enumerator = _enumerableOfStrings.GetEnumerator();
+					if (!enumerator.MoveNext())
+						return;
 
-				switch (Type)
-				{
-					case PostType.EnumerableOfString:
+					BufferIfNeeded(settings, ref buffer, ref stream);
+					do
 					{
-						if (_enumerableOfStrings == null) return;
-
-						using var enumerator = _enumerableOfStrings.GetEnumerator();
-						if (!enumerator.MoveNext())
-							return;
-
-						BufferIfNeeded(settings, ref buffer, ref stream);
-						do
-						{
-							var bytes = enumerator.Current.Utf8Bytes();
-							stream.Write(bytes, 0, bytes.Length);
-							stream.Write(NewLineByteArray, 0, 1);
-						} while (enumerator.MoveNext());
-
-						break;
-					}
-					case PostType.EnumerableOfObject:
-					{
-						if (_enumerableOfObject == null) return;
-
-						using var enumerator = _enumerableOfObject.GetEnumerator();
-						if (!enumerator.MoveNext())
-							return;
-
-						BufferIfNeeded(settings, ref buffer, ref stream);
-						do
-						{
-							var o = enumerator.Current;
-							settings.RequestResponseSerializer.Serialize(o, stream, SerializationFormatting.None);
-							stream.Write(NewLineByteArray, 0, 1);
-						} while (enumerator.MoveNext());
-
-						break;
-					}
-					default:
-						throw new ArgumentOutOfRangeException();
+						var bytes = enumerator.Current.Utf8Bytes();
+						stream.Write(bytes, 0, bytes.Length);
+						stream.Write(NewLineByteArray, 0, 1);
+					} while (enumerator.MoveNext());
+
+					break;
 				}
+				case PostType.EnumerableOfObject:
+				{
+					if (_enumerableOfObject == null) return;
+
+					using var enumerator = _enumerableOfObject.GetEnumerator();
+					if (!enumerator.MoveNext())
+						return;
 
-				FinishStream(writableStream, buffer, settings);
+					BufferIfNeeded(settings, ref buffer, ref stream);
+					do
+					{
+						var o = enumerator.Current;
+						settings.RequestResponseSerializer.Serialize(o, stream, SerializationFormatting.None);
+						stream.Write(NewLineByteArray, 0, 1);
+					} while (enumerator.MoveNext());
+
+					break;
+				}
+				default:
+					throw new ArgumentOutOfRangeException();
 			}
 
-			public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
-				CancellationToken cancellationToken)
-			{
-				if (Type != PostType.EnumerableOfObject && Type != PostType.EnumerableOfString)
-					throw new Exception(
-						$"{nameof(PostDataMultiJson<T>)} only does not support {nameof(PostType)}.{Type.GetStringValue()}");
+			FinishStream(writableStream, buffer, settings);
+		}
 
-				var stream = InitWrite(writableStream, settings, out var buffer, out _);
+		public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
+			CancellationToken cancellationToken)
+		{
+			if (Type != PostType.EnumerableOfObject && Type != PostType.EnumerableOfString)
+				throw new Exception(
+					$"{nameof(PostDataMultiJson<T>)} only does not support {nameof(PostType)}.{Type.GetStringValue()}");
+
+			var stream = InitWrite(writableStream, settings, out var buffer, out _);
 
-				switch (Type)
+			switch (Type)
+			{
+				case PostType.EnumerableOfString:
 				{
-					case PostType.EnumerableOfString:
-					{
-						if (_enumerableOfStrings == null)
-							return;
-
-						using var enumerator = _enumerableOfStrings.GetEnumerator();
-						if (!enumerator.MoveNext())
-							return;
-
-						BufferIfNeeded(settings, ref buffer, ref stream);
-						do
-						{
-							var bytes = enumerator.Current.Utf8Bytes();
-							await stream.WriteAsync(bytes, 0, bytes.Length, cancellationToken).ConfigureAwait(false);
-							await stream.WriteAsync(NewLineByteArray, 0, 1, cancellationToken).ConfigureAwait(false);
-						} while (enumerator.MoveNext());
-
-						break;
-					}
-					case PostType.EnumerableOfObject:
+					if (_enumerableOfStrings == null)
+						return;
+
+					using var enumerator = _enumerableOfStrings.GetEnumerator();
+					if (!enumerator.MoveNext())
+						return;
+
+					BufferIfNeeded(settings, ref buffer, ref stream);
+					do
 					{
-						if (_enumerableOfObject == null)
-							return;
-
-						using var enumerator = _enumerableOfObject.GetEnumerator();
-						if (!enumerator.MoveNext())
-							return;
-
-						BufferIfNeeded(settings, ref buffer, ref stream);
-						do
-						{
-							var o = enumerator.Current;
-							await settings.RequestResponseSerializer.SerializeAsync(o, stream,
-									SerializationFormatting.None, cancellationToken)
-								.ConfigureAwait(false);
-							await stream.WriteAsync(NewLineByteArray, 0, 1, cancellationToken).ConfigureAwait(false);
-						} while (enumerator.MoveNext());
-
-						break;
-					}
-					default:
-						throw new ArgumentOutOfRangeException();
+						var bytes = enumerator.Current.Utf8Bytes();
+						await stream.WriteAsync(bytes, 0, bytes.Length, cancellationToken).ConfigureAwait(false);
+						await stream.WriteAsync(NewLineByteArray, 0, 1, cancellationToken).ConfigureAwait(false);
+					} while (enumerator.MoveNext());
+
+					break;
 				}
+				case PostType.EnumerableOfObject:
+				{
+					if (_enumerableOfObject == null)
+						return;
 
-				await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
+					using var enumerator = _enumerableOfObject.GetEnumerator();
+					if (!enumerator.MoveNext())
+						return;
+
+					BufferIfNeeded(settings, ref buffer, ref stream);
+					do
+					{
+						var o = enumerator.Current;
+						await settings.RequestResponseSerializer.SerializeAsync(o, stream,
+								SerializationFormatting.None, cancellationToken)
+							.ConfigureAwait(false);
+						await stream.WriteAsync(NewLineByteArray, 0, 1, cancellationToken).ConfigureAwait(false);
+					} while (enumerator.MoveNext());
+
+					break;
+				}
+				default:
+					throw new ArgumentOutOfRangeException();
 			}
+
+			await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Requests/Body/PostData.Serializable.cs b/src/Elastic.Transport/Requests/Body/PostData.Serializable.cs
index 3935040..5f30c42 100644
--- a/src/Elastic.Transport/Requests/Body/PostData.Serializable.cs
+++ b/src/Elastic.Transport/Requests/Body/PostData.Serializable.cs
@@ -7,55 +7,54 @@
 using System.Threading.Tasks;
 using static Elastic.Transport.SerializationFormatting;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+public abstract partial class PostData
 {
-	public abstract partial class PostData
+	/// <summary>
+	/// Create a <see cref="PostData"/> instance that will serialize <paramref name="data"/> using
+	/// <see cref="Serializer"/>
+	/// </summary>
+	public static PostData Serializable<T>(T data) => new SerializableData<T>(data);
+
+	private class SerializableData<T> : PostData
 	{
-		/// <summary>
-		/// Create a <see cref="PostData"/> instance that will serialize <paramref name="data"/> using
-		/// <see cref="Serializer"/>
-		/// </summary>
-		public static PostData Serializable<T>(T data) => new SerializableData<T>(data);
+		private readonly T _serializable;
 
-		private class SerializableData<T> : PostData
+		public SerializableData(T item)
 		{
-			private readonly T _serializable;
-
-			public SerializableData(T item)
-			{
-				Type = PostType.Serializable;
-				_serializable = item;
-			}
-
-			public static implicit operator SerializableData<T>(T serializableData) =>
-				new SerializableData<T>(serializableData);
-
-			public override void Write(Stream writableStream, ITransportConfiguration settings)
-			{
-				MemoryStream buffer = null;
-				var stream = writableStream;
-				BufferIfNeeded(settings, ref buffer, ref stream);
-
-				var indent = settings.PrettyJson ? Indented : None;
-				settings.RequestResponseSerializer.Serialize(_serializable, stream, indent);
-
-				FinishStream(writableStream, buffer, settings);
-			}
-
-			public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
-				CancellationToken cancellationToken)
-			{
-				MemoryStream buffer = null;
-				var stream = writableStream;
-				BufferIfNeeded(settings, ref buffer, ref stream);
-
-				var indent = settings.PrettyJson ? Indented : None;
-				await settings.RequestResponseSerializer
-					.SerializeAsync(_serializable, stream, indent, cancellationToken)
-					.ConfigureAwait(false);
-
-				await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
-			}
+			Type = PostType.Serializable;
+			_serializable = item;
+		}
+
+		public static implicit operator SerializableData<T>(T serializableData) =>
+			new SerializableData<T>(serializableData);
+
+		public override void Write(Stream writableStream, ITransportConfiguration settings)
+		{
+			MemoryStream buffer = null;
+			var stream = writableStream;
+			BufferIfNeeded(settings, ref buffer, ref stream);
+
+			var indent = settings.PrettyJson ? Indented : None;
+			settings.RequestResponseSerializer.Serialize(_serializable, stream, indent);
+
+			FinishStream(writableStream, buffer, settings);
+		}
+
+		public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
+			CancellationToken cancellationToken)
+		{
+			MemoryStream buffer = null;
+			var stream = writableStream;
+			BufferIfNeeded(settings, ref buffer, ref stream);
+
+			var indent = settings.PrettyJson ? Indented : None;
+			await settings.RequestResponseSerializer
+				.SerializeAsync(_serializable, stream, indent, cancellationToken)
+				.ConfigureAwait(false);
+
+			await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Requests/Body/PostData.Streamable.cs b/src/Elastic.Transport/Requests/Body/PostData.Streamable.cs
index 4a36036..ab31659 100644
--- a/src/Elastic.Transport/Requests/Body/PostData.Streamable.cs
+++ b/src/Elastic.Transport/Requests/Body/PostData.Streamable.cs
@@ -7,63 +7,62 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+public abstract partial class PostData
 {
-	public abstract partial class PostData
+	/// <summary>
+	/// Create an instance of serializable data <paramref name="state"/>. This state is then passed to <paramref name="syncWriter"/>
+	/// and <paramref name="asyncWriter"/> along with the <see cref="Stream"/> to write to. Both will need to be supplied in order to
+	/// support both <see cref="Write"/> and <see cref="WriteAsync"/>
+	/// </summary>
+	/// <param name="state">The object we want to serialize later on</param>
+	/// <param name="syncWriter">A func receiving <paramref name="state"/> and a <see cref="Stream"/> to write to</param>
+	/// <param name="asyncWriter">A func receiving <paramref name="state"/> and a <see cref="Stream"/> to write to</param>
+	public static PostData StreamHandler<T>(T state, Action<T, Stream> syncWriter,
+		Func<T, Stream, CancellationToken, Task> asyncWriter) =>
+		new StreamableData<T>(state, syncWriter, asyncWriter);
+
+	/// <summary>
+	/// Represents an instance of <see cref="PostData"/> that can handle <see cref="PostType.StreamHandler"/>.
+	/// Allows users full control over how they want to write data to the stream.
+	/// </summary>
+	/// <typeparam name="T">The data or a state object used during writing, passed to the handlers to avoid boxing</typeparam>
+	private class StreamableData<T> : PostData
 	{
-		/// <summary>
-		/// Create an instance of serializable data <paramref name="state"/>. This state is then passed to <paramref name="syncWriter"/>
-		/// and <paramref name="asyncWriter"/> along with the <see cref="Stream"/> to write to. Both will need to be supplied in order to
-		/// support both <see cref="Write"/> and <see cref="WriteAsync"/>
-		/// </summary>
-		/// <param name="state">The object we want to serialize later on</param>
-		/// <param name="syncWriter">A func receiving <paramref name="state"/> and a <see cref="Stream"/> to write to</param>
-		/// <param name="asyncWriter">A func receiving <paramref name="state"/> and a <see cref="Stream"/> to write to</param>
-		public static PostData StreamHandler<T>(T state, Action<T, Stream> syncWriter,
-			Func<T, Stream, CancellationToken, Task> asyncWriter) =>
-			new StreamableData<T>(state, syncWriter, asyncWriter);
+		private readonly T _state;
+		private readonly Action<T, Stream> _syncWriter;
+		private readonly Func<T, Stream, CancellationToken, Task> _asyncWriter;
 
-		/// <summary>
-		/// Represents an instance of <see cref="PostData"/> that can handle <see cref="PostType.StreamHandler"/>.
-		/// Allows users full control over how they want to write data to the stream.
-		/// </summary>
-		/// <typeparam name="T">The data or a state object used during writing, passed to the handlers to avoid boxing</typeparam>
-		private class StreamableData<T> : PostData
+		public StreamableData(T state, Action<T, Stream> syncWriter,
+			Func<T, Stream, CancellationToken, Task> asyncWriter)
 		{
-			private readonly T _state;
-			private readonly Action<T, Stream> _syncWriter;
-			private readonly Func<T, Stream, CancellationToken, Task> _asyncWriter;
-
-			public StreamableData(T state, Action<T, Stream> syncWriter,
-				Func<T, Stream, CancellationToken, Task> asyncWriter)
-			{
-				_state = state;
-				const string message = "PostData.StreamHandler needs to handle both synchronous and async paths";
-				_syncWriter = syncWriter ?? throw new ArgumentNullException(nameof(syncWriter), message);
-				_asyncWriter = asyncWriter ?? throw new ArgumentNullException(nameof(asyncWriter), message);
-				if (_syncWriter == null || _asyncWriter == null)
-					throw new ArgumentNullException();
-				Type = PostType.StreamHandler;
-			}
+			_state = state;
+			const string message = "PostData.StreamHandler needs to handle both synchronous and async paths";
+			_syncWriter = syncWriter ?? throw new ArgumentNullException(nameof(syncWriter), message);
+			_asyncWriter = asyncWriter ?? throw new ArgumentNullException(nameof(asyncWriter), message);
+			if (_syncWriter == null || _asyncWriter == null)
+				throw new ArgumentNullException();
+			Type = PostType.StreamHandler;
+		}
 
-			public override void Write(Stream writableStream, ITransportConfiguration settings)
-			{
-				MemoryStream buffer = null;
-				var stream = writableStream;
-				BufferIfNeeded(settings, ref buffer, ref stream);
-				_syncWriter(_state, stream);
-				FinishStream(writableStream, buffer, settings);
-			}
+		public override void Write(Stream writableStream, ITransportConfiguration settings)
+		{
+			MemoryStream buffer = null;
+			var stream = writableStream;
+			BufferIfNeeded(settings, ref buffer, ref stream);
+			_syncWriter(_state, stream);
+			FinishStream(writableStream, buffer, settings);
+		}
 
-			public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
-				CancellationToken cancellationToken)
-			{
-				MemoryStream buffer = null;
-				var stream = writableStream;
-				BufferIfNeeded(settings, ref buffer, ref stream);
-				await _asyncWriter(_state, stream, cancellationToken).ConfigureAwait(false);
-				await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
-			}
+		public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
+			CancellationToken cancellationToken)
+		{
+			MemoryStream buffer = null;
+			var stream = writableStream;
+			BufferIfNeeded(settings, ref buffer, ref stream);
+			await _asyncWriter(_state, stream, cancellationToken).ConfigureAwait(false);
+			await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Requests/Body/PostData.String.cs b/src/Elastic.Transport/Requests/Body/PostData.String.cs
index 4477512..a5c096a 100644
--- a/src/Elastic.Transport/Requests/Body/PostData.String.cs
+++ b/src/Elastic.Transport/Requests/Body/PostData.String.cs
@@ -7,65 +7,64 @@
 using System.Threading.Tasks;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+public abstract partial class PostData
 {
-	public abstract partial class PostData
-	{
-		/// <summary>
-		/// Create a <see cref="PostData"/> instance that will write <paramref name="serializedString"/> to the output <see cref="Stream"/>
-		/// </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		public static PostData String(string serializedString) => new PostDataString(serializedString);
+	/// <summary>
+	/// Create a <see cref="PostData"/> instance that will write <paramref name="serializedString"/> to the output <see cref="Stream"/>
+	/// </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	public static PostData String(string serializedString) => new PostDataString(serializedString);
 
-		/// <summary>
-		/// string implicitly converts to <see cref="PostData"/> so you do not have to use the static <see cref="String"/>
-		/// factory method
-		/// </summary>
-		public static implicit operator PostData(string literalString) => String(literalString);
+	/// <summary>
+	/// string implicitly converts to <see cref="PostData"/> so you do not have to use the static <see cref="String"/>
+	/// factory method
+	/// </summary>
+	public static implicit operator PostData(string literalString) => String(literalString);
 
-		private class PostDataString : PostData
-		{
-			private readonly string _literalString;
+	private class PostDataString : PostData
+	{
+		private readonly string _literalString;
 
-			protected internal PostDataString(string item)
-			{
-				_literalString = item;
-				Type = PostType.LiteralString;
-			}
+		protected internal PostDataString(string item)
+		{
+			_literalString = item;
+			Type = PostType.LiteralString;
+		}
 
-			public override void Write(Stream writableStream, ITransportConfiguration settings)
-			{
-				if (string.IsNullOrEmpty(_literalString)) return;
+		public override void Write(Stream writableStream, ITransportConfiguration settings)
+		{
+			if (string.IsNullOrEmpty(_literalString)) return;
 
-				var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
+			var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
 
-				var stringBytes = WrittenBytes ?? _literalString.Utf8Bytes();
-				WrittenBytes ??= stringBytes;
-				if (!disableDirectStreaming)
-					stream.Write(stringBytes, 0, stringBytes.Length);
-				else
-					buffer = settings.MemoryStreamFactory.Create(stringBytes);
+			var stringBytes = WrittenBytes ?? _literalString.Utf8Bytes();
+			WrittenBytes ??= stringBytes;
+			if (!disableDirectStreaming)
+				stream.Write(stringBytes, 0, stringBytes.Length);
+			else
+				buffer = settings.MemoryStreamFactory.Create(stringBytes);
 
-				FinishStream(writableStream, buffer, settings);
-			}
+			FinishStream(writableStream, buffer, settings);
+		}
 
-			public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
-				CancellationToken cancellationToken)
-			{
-				if (string.IsNullOrEmpty(_literalString)) return;
+		public override async Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
+			CancellationToken cancellationToken)
+		{
+			if (string.IsNullOrEmpty(_literalString)) return;
 
-				var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
+			var stream = InitWrite(writableStream, settings, out var buffer, out var disableDirectStreaming);
 
-				var stringBytes = WrittenBytes ?? _literalString.Utf8Bytes();
-				WrittenBytes ??= stringBytes;
-				if (!disableDirectStreaming)
-					await stream.WriteAsync(stringBytes, 0, stringBytes.Length, cancellationToken)
-						.ConfigureAwait(false);
-				else
-					buffer = settings.MemoryStreamFactory.Create(stringBytes);
+			var stringBytes = WrittenBytes ?? _literalString.Utf8Bytes();
+			WrittenBytes ??= stringBytes;
+			if (!disableDirectStreaming)
+				await stream.WriteAsync(stringBytes, 0, stringBytes.Length, cancellationToken)
+					.ConfigureAwait(false);
+			else
+				buffer = settings.MemoryStreamFactory.Create(stringBytes);
 
-				await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
-			}
+			await FinishStreamAsync(writableStream, buffer, settings, cancellationToken).ConfigureAwait(false);
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Requests/Body/PostData.cs b/src/Elastic.Transport/Requests/Body/PostData.cs
index 2e589f6..68f2c52 100644
--- a/src/Elastic.Transport/Requests/Body/PostData.cs
+++ b/src/Elastic.Transport/Requests/Body/PostData.cs
@@ -7,131 +7,130 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Represents the data the the user wishes to send over the wire. This abstract base class exposes
+/// static factory methods to help you create wrap the various types of data we support.
+/// <para></para>
+/// <para>For raw bytes use <see cref="Bytes"/></para>
+/// <para>For raw string use <see cref="String"/></para>
+/// <para>To serialize an object use <see cref="Serializable{T}"/></para>
+/// <para>For <see cref="ReadOnlyMemory{T}"/> use <see cref="ReadOnlyMemory{T}"/></para>
+/// <para>To write your object directly to <see cref="Stream"/> using a handler use <see cref="StreamHandler{T}"/></para>
+/// <para>Multiline json is supported to using  <see cref="MultiJson{T}(System.Collections.Generic.IEnumerable{T})"/></para>
+/// <para>and  <see cref="MultiJson(System.Collections.Generic.IEnumerable{string})"/></para>
+/// </summary>
+public abstract partial class PostData
 {
 	/// <summary>
-	/// Represents the data the the user wishes to send over the wire. This abstract base class exposes
-	/// static factory methods to help you create wrap the various types of data we support.
-	/// <para></para>
-	/// <para>For raw bytes use <see cref="Bytes"/></para>
-	/// <para>For raw string use <see cref="String"/></para>
-	/// <para>To serialize an object use <see cref="Serializable{T}"/></para>
-	/// <para>For <see cref="ReadOnlyMemory{T}"/> use <see cref="ReadOnlyMemory{T}"/></para>
-	/// <para>To write your object directly to <see cref="Stream"/> using a handler use <see cref="StreamHandler{T}"/></para>
-	/// <para>Multiline json is supported to using  <see cref="MultiJson{T}(System.Collections.Generic.IEnumerable{T})"/></para>
-	/// <para>and  <see cref="MultiJson(System.Collections.Generic.IEnumerable{string})"/></para>
+	/// The buffer size to use when calling <see cref="Stream.CopyTo(System.IO.Stream, int)"/>
 	/// </summary>
-	public abstract partial class PostData
+	// ReSharper disable once MemberCanBePrivate.Global
+	protected const int BufferSize = 81920;
+
+	/// <summary> A static byte[] that hols a single new line feed </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	protected static readonly byte[] NewLineByteArray = {(byte) '\n'};
+
+	/// <summary>
+	/// By setting this to true, <see cref="Write"/> and <see cref="WriteAsync"/> will buffer the data and
+	/// expose it on <see cref="WrittenBytes"/>
+	/// </summary>
+	public bool? DisableDirectStreaming { get; set; }
+
+	/// <summary> Reports the data this instance is wrapping </summary>
+	// ReSharper disable once MemberCanBeProtected.Global
+	public PostType Type { get; private set; }
+
+	/// <summary>
+	/// If <see cref="DisableDirectStreaming" /> is set to true, this will hold the buffered data after <see cref="Write"/>
+	/// or <see cref="WriteAsync"/> is called
+	/// </summary>
+	public byte[] WrittenBytes { get; private set; }
+
+	/// <summary> A static instance that represents a body with no data </summary>
+	// ReSharper disable once UnusedMember.Global
+	public static PostData Empty => new PostDataString(string.Empty);
+
+	/// <summary>
+	/// Implementations of <see cref="PostData"/> are expected to implement writing the data they hold to
+	/// <paramref name="writableStream"/>
+	/// </summary>
+	public abstract void Write(Stream writableStream, ITransportConfiguration settings);
+
+	/// <summary>
+	/// Implementations of <see cref="PostData"/> are expected to implement writing the data they hold to
+	/// <paramref name="writableStream"/>
+	/// </summary>
+	public abstract Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
+		CancellationToken cancellationToken);
+
+	/// <summary>
+	/// byte[] implicitly converts to <see cref="PostData"/> so you do not have to use the static <see cref="Bytes"/>
+	/// factory method
+	/// </summary>
+	public static implicit operator PostData(byte[] byteArray) => Bytes(byteArray);
+
+	/// <summary> Sets up the stream and buffer and determines if direct streaming should be disabled </summary>
+	// ReSharper disable once MemberCanBePrivate.Global
+	protected Stream InitWrite(Stream writableStream, ITransportConfiguration settings, out MemoryStream buffer,
+		out bool disableDirectStreaming)
 	{
-		/// <summary>
-		/// The buffer size to use when calling <see cref="Stream.CopyTo(System.IO.Stream, int)"/>
-		/// </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		protected const int BufferSize = 81920;
-
-		/// <summary> A static byte[] that hols a single new line feed </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		protected static readonly byte[] NewLineByteArray = {(byte) '\n'};
-
-		/// <summary>
-		/// By setting this to true, <see cref="Write"/> and <see cref="WriteAsync"/> will buffer the data and
-		/// expose it on <see cref="WrittenBytes"/>
-		/// </summary>
-		public bool? DisableDirectStreaming { get; set; }
-
-		/// <summary> Reports the data this instance is wrapping </summary>
-		// ReSharper disable once MemberCanBeProtected.Global
-		public PostType Type { get; private set; }
-
-		/// <summary>
-		/// If <see cref="DisableDirectStreaming" /> is set to true, this will hold the buffered data after <see cref="Write"/>
-		/// or <see cref="WriteAsync"/> is called
-		/// </summary>
-		public byte[] WrittenBytes { get; private set; }
-
-		/// <summary> A static instance that represents a body with no data </summary>
-		// ReSharper disable once UnusedMember.Global
-		public static PostData Empty => new PostDataString(string.Empty);
-
-		/// <summary>
-		/// Implementations of <see cref="PostData"/> are expected to implement writing the data they hold to
-		/// <paramref name="writableStream"/>
-		/// </summary>
-		public abstract void Write(Stream writableStream, ITransportConfiguration settings);
-
-		/// <summary>
-		/// Implementations of <see cref="PostData"/> are expected to implement writing the data they hold to
-		/// <paramref name="writableStream"/>
-		/// </summary>
-		public abstract Task WriteAsync(Stream writableStream, ITransportConfiguration settings,
-			CancellationToken cancellationToken);
-
-		/// <summary>
-		/// byte[] implicitly converts to <see cref="PostData"/> so you do not have to use the static <see cref="Bytes"/>
-		/// factory method
-		/// </summary>
-		public static implicit operator PostData(byte[] byteArray) => Bytes(byteArray);
-
-		/// <summary> Sets up the stream and buffer and determines if direct streaming should be disabled </summary>
-		// ReSharper disable once MemberCanBePrivate.Global
-		protected Stream InitWrite(Stream writableStream, ITransportConfiguration settings, out MemoryStream buffer,
-			out bool disableDirectStreaming)
-		{
-			buffer = null;
-			var stream = writableStream;
-			disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
-			return stream;
-		}
-
-
-		/// <summary>
-		/// Based on <paramref name="settings"/> or <see cref="DisableDirectStreaming"/> this will swap <paramref name="stream"/>
-		/// with <paramref name="buffer"/> after allocating <paramref name="buffer"/>.
-		/// <para>NOTE: <paramref name="buffer"/> is expected to be null when called and may be null when this method returns</para>
-		/// </summary>
-		protected void BufferIfNeeded(ITransportConfiguration settings, ref MemoryStream buffer,
-			ref Stream stream)
-		{
-			var disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
-			if (!disableDirectStreaming) return;
-
-			buffer = settings.MemoryStreamFactory.Create();
-			stream = buffer;
-		}
-
-		/// <summary>
-		/// Implementation of <see cref="Write"/> may call this to make sure <paramref name="buffer"/> makes it to <see cref="WrittenBytes"/>
-		/// if <see cref="DisableDirectStreaming"/> or <paramref name="settings"/> request to buffer the data.
-		/// </summary>
-		protected void FinishStream(Stream writableStream, MemoryStream buffer, ITransportConfiguration settings)
-		{
-			var disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
-			if (buffer == null || !disableDirectStreaming) return;
-
-			buffer.Position = 0;
-			buffer.CopyTo(writableStream, BufferSize);
-			WrittenBytes ??= buffer.ToArray();
-		}
-
-		/// <summary>
-		/// Implementation of <see cref="WriteAsync"/> may call this to make sure <paramref name="buffer"/> makes it to <see cref="WrittenBytes"/>
-		/// if <see cref="DisableDirectStreaming"/> or <paramref name="settings"/> request to buffer the data.
-		/// </summary>
-		protected async
+		buffer = null;
+		var stream = writableStream;
+		disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
+		return stream;
+	}
+
+
+	/// <summary>
+	/// Based on <paramref name="settings"/> or <see cref="DisableDirectStreaming"/> this will swap <paramref name="stream"/>
+	/// with <paramref name="buffer"/> after allocating <paramref name="buffer"/>.
+	/// <para>NOTE: <paramref name="buffer"/> is expected to be null when called and may be null when this method returns</para>
+	/// </summary>
+	protected void BufferIfNeeded(ITransportConfiguration settings, ref MemoryStream buffer,
+		ref Stream stream)
+	{
+		var disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
+		if (!disableDirectStreaming) return;
+
+		buffer = settings.MemoryStreamFactory.Create();
+		stream = buffer;
+	}
+
+	/// <summary>
+	/// Implementation of <see cref="Write"/> may call this to make sure <paramref name="buffer"/> makes it to <see cref="WrittenBytes"/>
+	/// if <see cref="DisableDirectStreaming"/> or <paramref name="settings"/> request to buffer the data.
+	/// </summary>
+	protected void FinishStream(Stream writableStream, MemoryStream buffer, ITransportConfiguration settings)
+	{
+		var disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
+		if (buffer == null || !disableDirectStreaming) return;
+
+		buffer.Position = 0;
+		buffer.CopyTo(writableStream, BufferSize);
+		WrittenBytes ??= buffer.ToArray();
+	}
+
+	/// <summary>
+	/// Implementation of <see cref="WriteAsync"/> may call this to make sure <paramref name="buffer"/> makes it to <see cref="WrittenBytes"/>
+	/// if <see cref="DisableDirectStreaming"/> or <paramref name="settings"/> request to buffer the data.
+	/// </summary>
+	protected async
 #if !NETSTANDARD2_0 && !NETFRAMEWORK
-			ValueTask
+		ValueTask
 #else
-			Task
+		Task
 #endif
-			FinishStreamAsync(Stream writableStream, MemoryStream buffer, ITransportConfiguration settings,
-				CancellationToken ctx)
-		{
-			var disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
-			if (buffer == null || !disableDirectStreaming) return;
-
-			buffer.Position = 0;
-			await buffer.CopyToAsync(writableStream, BufferSize, ctx).ConfigureAwait(false);
-			WrittenBytes ??= buffer.ToArray();
-		}
+		FinishStreamAsync(Stream writableStream, MemoryStream buffer, ITransportConfiguration settings,
+			CancellationToken ctx)
+	{
+		var disableDirectStreaming = DisableDirectStreaming ?? settings.DisableDirectStreaming;
+		if (buffer == null || !disableDirectStreaming) return;
+
+		buffer.Position = 0;
+		await buffer.CopyToAsync(writableStream, BufferSize, ctx).ConfigureAwait(false);
+		WrittenBytes ??= buffer.ToArray();
 	}
 }
diff --git a/src/Elastic.Transport/Requests/Body/PostType.cs b/src/Elastic.Transport/Requests/Body/PostType.cs
index 8158063..c69974f 100644
--- a/src/Elastic.Transport/Requests/Body/PostType.cs
+++ b/src/Elastic.Transport/Requests/Body/PostType.cs
@@ -6,54 +6,53 @@
 using System;
 #endif
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Describes the type of data the user wants transmit over the transport
+/// </summary>
+public enum PostType
 {
 	/// <summary>
-	/// Describes the type of data the user wants transmit over the transport
+	/// A raw array of <see cref="byte"/>'s to be send over the wire
+	/// <para>Instantiate using <see cref="PostData.Bytes"/></para>
 	/// </summary>
-	public enum PostType
-	{
-		/// <summary>
-		/// A raw array of <see cref="byte"/>'s to be send over the wire
-		/// <para>Instantiate using <see cref="PostData.Bytes"/></para>
-		/// </summary>
-		ByteArray,
+	ByteArray,
 #if !NETSTANDARD2_0 && !NETFRAMEWORK
-		/// <summary>
-		/// An instance of <see cref="ReadOnlyMemory{T}"/> where T is byte
-		/// <para>Instantiate using <see cref="PostData.ReadOnlyMemory"/></para>
-		/// </summary>
-		ReadOnlyMemory,
+	/// <summary>
+	/// An instance of <see cref="ReadOnlyMemory{T}"/> where T is byte
+	/// <para>Instantiate using <see cref="PostData.ReadOnlyMemory"/></para>
+	/// </summary>
+	ReadOnlyMemory,
 #endif
-		/// <summary>
-		/// An instance of <see cref="string"/>
-		/// <para>Instantiate using <see cref="PostData.String"/></para>
-		/// </summary>
-		LiteralString,
-
-		/// <summary>
-		/// An instance of a user provided value to be serialized by <see cref="Serializer"/>
-		/// <para>Instantiate using <see cref="PostData.Serializable{T}"/></para>
-		/// </summary>
-		Serializable,
-
-		/// <summary>
-		/// An enumerable of <see cref="string"/> this will be serialized using ndjson multiline syntax
-		/// <para>Instantiate using <see cref="PostData.MultiJson(System.Collections.Generic.IEnumerable{string})"/></para>
-		/// </summary>
-		EnumerableOfString,
-
-		/// <summary>
-		/// An enumerable of <see cref="object"/> this will be serialized using ndjson multiline syntax
-		/// <para>Instantiate using <see cref="PostData.MultiJson{T}(System.Collections.Generic.IEnumerable{T})"/></para>
-		/// </summary>
-		EnumerableOfObject,
-
-		/// <summary>
-		/// The user provided a delegate to write the instance on <see cref="PostData"/> manually and directly
-		/// <para>Instantiate using <see cref="PostData.StreamHandler{T}"/></para>
-		/// </summary>
-		StreamHandler,
-
-	}
+	/// <summary>
+	/// An instance of <see cref="string"/>
+	/// <para>Instantiate using <see cref="PostData.String"/></para>
+	/// </summary>
+	LiteralString,
+
+	/// <summary>
+	/// An instance of a user provided value to be serialized by <see cref="Serializer"/>
+	/// <para>Instantiate using <see cref="PostData.Serializable{T}"/></para>
+	/// </summary>
+	Serializable,
+
+	/// <summary>
+	/// An enumerable of <see cref="string"/> this will be serialized using ndjson multiline syntax
+	/// <para>Instantiate using <see cref="PostData.MultiJson(System.Collections.Generic.IEnumerable{string})"/></para>
+	/// </summary>
+	EnumerableOfString,
+
+	/// <summary>
+	/// An enumerable of <see cref="object"/> this will be serialized using ndjson multiline syntax
+	/// <para>Instantiate using <see cref="PostData.MultiJson{T}(System.Collections.Generic.IEnumerable{T})"/></para>
+	/// </summary>
+	EnumerableOfObject,
+
+	/// <summary>
+	/// The user provided a delegate to write the instance on <see cref="PostData"/> manually and directly
+	/// <para>Instantiate using <see cref="PostData.StreamHandler{T}"/></para>
+	/// </summary>
+	StreamHandler,
+
 }
diff --git a/src/Elastic.Transport/Requests/IRequestParameters.cs b/src/Elastic.Transport/Requests/IRequestParameters.cs
deleted file mode 100644
index f09203e..0000000
--- a/src/Elastic.Transport/Requests/IRequestParameters.cs
+++ /dev/null
@@ -1,55 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System.Collections.Generic;
-
-// ReSharper disable once CheckNamespace
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// Per request specific parameters. Holds literal url request parameters as well as
-	/// per request configuration overrides on <see cref="RequestConfiguration"/>
-	/// </summary>
-	public interface IRequestParameters
-	{
-		/// <summary> Allows you to completely circumvent the serializer to build the final response.</summary>
-		CustomResponseBuilder CustomResponseBuilder { get; set; }
-
-		/// <summary>
-		/// The querystring that should be appended to the path of the request
-		/// </summary>
-		Dictionary<string, object> QueryString { get; set; }
-
-		/// <summary>
-		/// Configuration for this specific request, i.e disable sniffing, custom timeouts etcetera.
-		/// </summary>
-		IRequestConfiguration RequestConfiguration { get; set; }
-
-		/// <summary> Sets a query string param. If <paramref name="value" /> is null and the parameter exists it will be removed </summary>
-		/// <param name="name">The query string parameter to add</param>
-		/// <param name="value">The value to set, if null removes <paramref name="name" /> from the query string if it exists</param>
-		void SetQueryString(string name, object value);
-
-		/// <summary>
-		/// Returns whether the query string <paramref name="name"/> was previously set already
-		/// </summary>
-		bool ContainsQueryString(string name);
-
-		/// <summary>
-		/// Get's the value as its stored on the querystring using its original type
-		/// </summary>
-		TOut GetQueryStringValue<TOut>(string name);
-
-		/// <summary>
-		/// Gets the stringified representation of a query string value as it would be sent to Elasticsearch.
-		/// </summary>
-		string GetResolvedQueryStringValue(string name, ITransportConfiguration transportConfiguration);
-
-		/// <summary>
-		/// Gets the HTTP Accept Header value from the shortened name. If the shortened name is not recognized,
-		/// <c>null</c> is returned.
-		/// </summary>
-		string AcceptHeaderFromFormat(string format);
-	}
-}
diff --git a/src/Elastic.Transport/Requests/IUrlParameter.cs b/src/Elastic.Transport/Requests/IUrlParameter.cs
index d9c893e..ef4834b 100644
--- a/src/Elastic.Transport/Requests/IUrlParameter.cs
+++ b/src/Elastic.Transport/Requests/IUrlParameter.cs
@@ -2,12 +2,11 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary> Implementers define an object that can be serialized as a query string parameter </summary>
+public interface IUrlParameter
 {
-	/// <summary> Implementers define an object that can be serialized as a query string parameter </summary>
-	public interface IUrlParameter
-	{
-		/// <summary> Get the a string representation using <paramref name="settings"/> </summary>
-		string GetString(ITransportConfiguration settings);
-	}
+	/// <summary> Get the a string representation using <paramref name="settings"/> </summary>
+	string GetString(ITransportConfiguration settings);
 }
diff --git a/src/Elastic.Transport/Requests/MetaData/DefaultMetaHeaderProvider.cs b/src/Elastic.Transport/Requests/MetaData/DefaultMetaHeaderProvider.cs
index 6fa9a72..03e61ec 100644
--- a/src/Elastic.Transport/Requests/MetaData/DefaultMetaHeaderProvider.cs
+++ b/src/Elastic.Transport/Requests/MetaData/DefaultMetaHeaderProvider.cs
@@ -4,61 +4,60 @@
 
 using System;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// 
+/// </summary>
+public sealed class DefaultMetaHeaderProvider : MetaHeaderProvider
 {
+	private const string MetaHeaderName = "x-elastic-client-meta";
+
+	private readonly MetaDataHeader _asyncMetaDataHeader;
+	private readonly MetaDataHeader _syncMetaDataHeader;
+
 	/// <summary>
 	/// 
 	/// </summary>
-	public sealed class DefaultMetaHeaderProvider : MetaHeaderProvider
+	public DefaultMetaHeaderProvider(Type clientType, string serviceIdentifier)
 	{
-		private const string MetaHeaderName = "x-elastic-client-meta";
-
-		private readonly MetaDataHeader _asyncMetaDataHeader;
-		private readonly MetaDataHeader _syncMetaDataHeader;
-
-		/// <summary>
-		/// 
-		/// </summary>
-		public DefaultMetaHeaderProvider(Type clientType, string serviceIdentifier)
-		{
-			var clientVersionInfo = ReflectionVersionInfo.Create(clientType);
-			_asyncMetaDataHeader = new MetaDataHeader(clientVersionInfo, serviceIdentifier, true);
-			_syncMetaDataHeader = new MetaDataHeader(clientVersionInfo, serviceIdentifier, false);
-		}
+		var clientVersionInfo = ReflectionVersionInfo.Create(clientType);
+		_asyncMetaDataHeader = new MetaDataHeader(clientVersionInfo, serviceIdentifier, true);
+		_syncMetaDataHeader = new MetaDataHeader(clientVersionInfo, serviceIdentifier, false);
+	}
 
-		/// <summary>
-		/// 
-		/// </summary>
-		public override string HeaderName => MetaHeaderName;
+	/// <summary>
+	/// 
+	/// </summary>
+	public override string HeaderName => MetaHeaderName;
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="requestData"></param>
-		/// <returns></returns>
-		public override string ProduceHeaderValue(RequestData requestData)
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="requestData"></param>
+	/// <returns></returns>
+	public override string ProduceHeaderValue(RequestData requestData)
+	{
+		try
 		{
-			try
-			{
-				if (requestData.ConnectionSettings.DisableMetaHeader)
-					return null;
+			if (requestData.ConnectionSettings.DisableMetaHeader)
+				return null;
 
-				var headerValue = requestData.IsAsync
-					? _asyncMetaDataHeader.ToString()
-					: _syncMetaDataHeader.ToString();
+			var headerValue = requestData.IsAsync
+				? _asyncMetaDataHeader.ToString()
+				: _syncMetaDataHeader.ToString();
 
-				// TODO - Cache values against key to avoid allocating a string each time
-				if (requestData.RequestMetaData.TryGetValue(RequestMetaData.HelperKey, out var helperSuffix))
-					headerValue = $"{headerValue},h={helperSuffix}";
+			// TODO - Cache values against key to avoid allocating a string each time
+			if (requestData.RequestMetaData.TryGetValue(RequestMetaData.HelperKey, out var helperSuffix))
+				headerValue = $"{headerValue},h={helperSuffix}";
 
-				return headerValue;
-			}
-			catch
-			{
-				// Don't fail the application just because we cannot create this optional header
-			}
-
-			return string.Empty;
+			return headerValue;
+		}
+		catch
+		{
+			// Don't fail the application just because we cannot create this optional header
 		}
+
+		return string.Empty;
 	}
 }
diff --git a/src/Elastic.Transport/Requests/MetaData/MetaDataHeader.cs b/src/Elastic.Transport/Requests/MetaData/MetaDataHeader.cs
index 8e284ea..83f7535 100644
--- a/src/Elastic.Transport/Requests/MetaData/MetaDataHeader.cs
+++ b/src/Elastic.Transport/Requests/MetaData/MetaDataHeader.cs
@@ -4,77 +4,76 @@
 
 using System.Text;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// 
+/// </summary>
+public sealed class MetaDataHeader
 {
+	private const char _separator = ',';
+
+	private readonly string _headerValue;
+
 	/// <summary>
 	/// 
 	/// </summary>
-	public sealed class MetaDataHeader
+	/// <param name="version"></param>
+	/// <param name="serviceIdentifier"></param>
+	/// <param name="isAsync"></param>
+	public MetaDataHeader(VersionInfo version, string serviceIdentifier, bool isAsync)
 	{
-		private const char _separator = ',';
+		if (serviceIdentifier != "et")
+			TransportVersion = ReflectionVersionInfo.Create<HttpTransport>().ToString();
+		
+		ClientVersion = version.ToString();
+		RuntimeVersion = new RuntimeVersionInfo().ToString();
+		ServiceIdentifier = serviceIdentifier;
 
-		private readonly string _headerValue;
+		// This code is expected to be called infrequently so we're not concerned with over optimising this
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="version"></param>
-		/// <param name="serviceIdentifier"></param>
-		/// <param name="isAsync"></param>
-		public MetaDataHeader(VersionInfo version, string serviceIdentifier, bool isAsync)
-		{
-			if (serviceIdentifier != "et")
-				TransportVersion = ReflectionVersionInfo.Create<ITransport>().ToString();
-			
-			ClientVersion = version.ToString();
-			RuntimeVersion = new RuntimeVersionInfo().ToString();
-			ServiceIdentifier = serviceIdentifier;
+		var builder = new StringBuilder(64)
+			.Append(serviceIdentifier).Append("=").Append(ClientVersion).Append(_separator)
+			.Append("a=").Append(isAsync ? "1" : "0").Append(_separator)
+			.Append("net=").Append(RuntimeVersion).Append(_separator)
+			.Append(_httpClientIdentifier).Append("=").Append(RuntimeVersion);
 
-			// This code is expected to be called infrequently so we're not concerned with over optimising this
+		if (!string.IsNullOrEmpty(TransportVersion))
+			builder.Append(_separator).Append("t=").Append(TransportVersion);
 
-			var builder = new StringBuilder(64)
-				.Append(serviceIdentifier).Append("=").Append(ClientVersion).Append(_separator)
-				.Append("a=").Append(isAsync ? "1" : "0").Append(_separator)
-				.Append("net=").Append(RuntimeVersion).Append(_separator)
-				.Append(_httpClientIdentifier).Append("=").Append(RuntimeVersion);
-
-			if (!string.IsNullOrEmpty(TransportVersion))
-				builder.Append(_separator).Append("t=").Append(TransportVersion);
-
-			_headerValue = builder.ToString();
-		}
+		_headerValue = builder.ToString();
+	}
 
-		private static readonly string _httpClientIdentifier =
+	private static readonly string _httpClientIdentifier =
 #if DOTNETCORE
-			ConnectionInfo.UsingCurlHandler ? "cu" : "so";
+		ConnectionInfo.UsingCurlHandler ? "cu" : "so";
 #else
-			"wr";
+		"wr";
 #endif
 
-		/// <summary>
-		/// 
-		/// </summary>
-		public string ServiceIdentifier { get; private set; }
+	/// <summary>
+	/// 
+	/// </summary>
+	public string ServiceIdentifier { get; private set; }
 
-		/// <summary>
-		/// 
-		/// </summary>
-		public string ClientVersion { get; private set; }
+	/// <summary>
+	/// 
+	/// </summary>
+	public string ClientVersion { get; private set; }
 
-		/// <summary>
-		/// 
-		/// </summary>
-		public string TransportVersion { get; private set; }
+	/// <summary>
+	/// 
+	/// </summary>
+	public string TransportVersion { get; private set; }
 
-		/// <summary>
-		/// 
-		/// </summary>
-		public string RuntimeVersion { get; private set; }
+	/// <summary>
+	/// 
+	/// </summary>
+	public string RuntimeVersion { get; private set; }
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <returns></returns>
-		public override string ToString() => _headerValue;
-	}
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <returns></returns>
+	public override string ToString() => _headerValue;
 }
diff --git a/src/Elastic.Transport/Requests/MetaData/MetaHeaderProvider.cs b/src/Elastic.Transport/Requests/MetaData/MetaHeaderProvider.cs
new file mode 100644
index 0000000..9f58c0b
--- /dev/null
+++ b/src/Elastic.Transport/Requests/MetaData/MetaHeaderProvider.cs
@@ -0,0 +1,23 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+namespace Elastic.Transport;
+
+/// <summary>
+/// TODO
+/// </summary>
+public abstract class MetaHeaderProvider
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	public abstract string HeaderName { get; }
+
+	/// <summary>
+	/// TODO
+	/// </summary>
+	/// <param name="requestData"></param>
+	/// <returns></returns>
+	public abstract string ProduceHeaderValue(RequestData requestData);
+}
diff --git a/src/Elastic.Transport/Requests/MetaData/MetaHeaderProviderBase.cs b/src/Elastic.Transport/Requests/MetaData/MetaHeaderProviderBase.cs
deleted file mode 100644
index 96d8df5..0000000
--- a/src/Elastic.Transport/Requests/MetaData/MetaHeaderProviderBase.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// TODO
-	/// </summary>
-	public abstract class MetaHeaderProvider
-	{
-		/// <summary>
-		/// 
-		/// </summary>
-		public abstract string HeaderName { get; }
-
-		/// <summary>
-		/// TODO
-		/// </summary>
-		/// <param name="requestData"></param>
-		/// <returns></returns>
-		public abstract string ProduceHeaderValue(RequestData requestData);
-	}
-}
diff --git a/src/Elastic.Transport/Requests/MetaData/ReflectionVersionInfo.cs b/src/Elastic.Transport/Requests/MetaData/ReflectionVersionInfo.cs
index cbfcee3..e55359b 100644
--- a/src/Elastic.Transport/Requests/MetaData/ReflectionVersionInfo.cs
+++ b/src/Elastic.Transport/Requests/MetaData/ReflectionVersionInfo.cs
@@ -7,51 +7,50 @@
 using System.Reflection;
 using System.Text.RegularExpressions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+internal sealed class ReflectionVersionInfo : VersionInfo
 {
-	internal sealed class ReflectionVersionInfo : VersionInfo
-	{
-		private static readonly Regex VersionRegex = new(@"^\d+\.\d+\.\d\-?");
+	private static readonly Regex VersionRegex = new(@"^\d+\.\d+\.\d\-?");
 
-		public static readonly ReflectionVersionInfo Empty = new() { Version = new Version(0, 0, 0), IsPrerelease = false };
+	public static readonly ReflectionVersionInfo Empty = new() { Version = new Version(0, 0, 0), IsPrerelease = false };
 
-		private ReflectionVersionInfo() { }
+	private ReflectionVersionInfo() { }
 
-		public static ReflectionVersionInfo Create<T>()
-		{
-			var fullVersion = DetermineVersionFromType(typeof(T));
-			var clientVersion = new ReflectionVersionInfo();
-			clientVersion.StoreVersion(fullVersion);
-			return clientVersion;
-		}
+	public static ReflectionVersionInfo Create<T>()
+	{
+		var fullVersion = DetermineVersionFromType(typeof(T));
+		var clientVersion = new ReflectionVersionInfo();
+		clientVersion.StoreVersion(fullVersion);
+		return clientVersion;
+	}
 
-		public static ReflectionVersionInfo Create(Type type)
-		{
-			var fullVersion = DetermineVersionFromType(type);
-			var clientVersion = new ReflectionVersionInfo();
-			clientVersion.StoreVersion(fullVersion);
-			return clientVersion;
-		}
+	public static ReflectionVersionInfo Create(Type type)
+	{
+		var fullVersion = DetermineVersionFromType(type);
+		var clientVersion = new ReflectionVersionInfo();
+		clientVersion.StoreVersion(fullVersion);
+		return clientVersion;
+	}
 
-		private static string DetermineVersionFromType(Type type)
+	private static string DetermineVersionFromType(Type type)
+	{
+		try
 		{
-			try
-			{
-				var productVersion = "8.0.0-alpha.8+02b315d290415a4eb153beb827a879d037e904f6 (Microsoft Windows 10.0.19044; .NET 6.0.4; Elastic.Clients.Elasticsearch)"; //FileVersionInfo.GetVersionInfo(type.GetTypeInfo().Assembly.Location)?.ProductVersion ?? EmptyVersion;
-
-				if (productVersion == EmptyVersion)
-					productVersion = Assembly.GetAssembly(type).GetName().Version.ToString();
+			var productVersion = "8.0.0-alpha.8+02b315d290415a4eb153beb827a879d037e904f6 (Microsoft Windows 10.0.19044; .NET 6.0.4; Elastic.Clients.Elasticsearch)"; //FileVersionInfo.GetVersionInfo(type.GetTypeInfo().Assembly.Location)?.ProductVersion ?? EmptyVersion;
 
-				var match = VersionRegex.Match(productVersion);
+			if (productVersion == EmptyVersion)
+				productVersion = Assembly.GetAssembly(type).GetName().Version.ToString();
 
-				return match.Success ? match.Value : EmptyVersion;
-			}
-			catch
-			{
-				// ignore failures and fall through
-			}
+			var match = VersionRegex.Match(productVersion);
 
-			return EmptyVersion;
+			return match.Success ? match.Value : EmptyVersion;
 		}
+		catch
+		{
+			// ignore failures and fall through
+		}
+
+		return EmptyVersion;
 	}
 }
diff --git a/src/Elastic.Transport/Requests/MetaData/RequestConfigurationExtensions.cs b/src/Elastic.Transport/Requests/MetaData/RequestConfigurationExtensions.cs
index 3432e59..b2a90fc 100644
--- a/src/Elastic.Transport/Requests/MetaData/RequestConfigurationExtensions.cs
+++ b/src/Elastic.Transport/Requests/MetaData/RequestConfigurationExtensions.cs
@@ -4,29 +4,28 @@
 
 using System;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// 
+/// </summary>
+public static class RequestConfigurationExtensions
 {
 	/// <summary>
 	/// 
 	/// </summary>
-	public static class RequestConfigurationExtensions
+	/// <param name="requestConfiguration"></param>
+	/// <param name="requestMetaData"></param>
+	/// <exception cref="ArgumentNullException"></exception>
+	public static void SetRequestMetaData(this IRequestConfiguration requestConfiguration, RequestMetaData requestMetaData)
 	{
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="requestConfiguration"></param>
-		/// <param name="requestMetaData"></param>
-		/// <exception cref="ArgumentNullException"></exception>
-		public static void SetRequestMetaData(this IRequestConfiguration requestConfiguration, RequestMetaData requestMetaData)
-		{
-			if (requestConfiguration is null)
-				throw new ArgumentNullException(nameof(requestConfiguration));
+		if (requestConfiguration is null)
+			throw new ArgumentNullException(nameof(requestConfiguration));
 
-			if (requestMetaData is null)
-				throw new ArgumentNullException(nameof(requestMetaData));
+		if (requestMetaData is null)
+			throw new ArgumentNullException(nameof(requestMetaData));
 
-			requestConfiguration.RequestMetaData = requestMetaData;
-		}
+		requestConfiguration.RequestMetaData = requestMetaData;
 	}
-
 }
+
diff --git a/src/Elastic.Transport/Requests/MetaData/RequestMetaData.cs b/src/Elastic.Transport/Requests/MetaData/RequestMetaData.cs
index a59eacc..551ea9f 100644
--- a/src/Elastic.Transport/Requests/MetaData/RequestMetaData.cs
+++ b/src/Elastic.Transport/Requests/MetaData/RequestMetaData.cs
@@ -5,38 +5,37 @@
 using System.Collections.Generic;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Holds meta data about a client request.
+/// </summary>
+public sealed class RequestMetaData
 {
 	/// <summary>
-	/// Holds meta data about a client request.
+	/// Reserved key for a meta data entry which identifies the helper which produced the request.
 	/// </summary>
-	public sealed class RequestMetaData
-	{
-		/// <summary>
-		/// Reserved key for a meta data entry which identifies the helper which produced the request.
-		/// </summary>
-		internal const string HelperKey = "helper";
+	internal const string HelperKey = "helper";
 
-		private Dictionary<string, string> _metaDataItems;
+	private Dictionary<string, string> _metaDataItems;
 
-		internal bool TryAddMetaData(string key, string value)
-		{
-			_metaDataItems ??= new Dictionary<string, string>();
+	internal bool TryAddMetaData(string key, string value)
+	{
+		_metaDataItems ??= new Dictionary<string, string>();
 
 #if NETSTANDARD2_1
-			return _metaDataItems.TryAdd(key, value);
+		return _metaDataItems.TryAdd(key, value);
 #else
-			if (_metaDataItems.ContainsKey(key))
-				return false;
+		if (_metaDataItems.ContainsKey(key))
+			return false;
 
-			_metaDataItems.Add(key, value);
-			return true;
+		_metaDataItems.Add(key, value);
+		return true;
 #endif
-		}
-
-		/// <summary>
-		/// 
-		/// </summary>
-		public IReadOnlyDictionary<string, string> Items => _metaDataItems ?? EmptyReadOnly<string, string>.Dictionary;
 	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public IReadOnlyDictionary<string, string> Items => _metaDataItems ?? EmptyReadOnly<string, string>.Dictionary;
 }
diff --git a/src/Elastic.Transport/Requests/MetaData/RequestMetaDataExtensions.cs b/src/Elastic.Transport/Requests/MetaData/RequestMetaDataExtensions.cs
index 80edf4e..4217bdf 100644
--- a/src/Elastic.Transport/Requests/MetaData/RequestMetaDataExtensions.cs
+++ b/src/Elastic.Transport/Requests/MetaData/RequestMetaDataExtensions.cs
@@ -4,24 +4,23 @@
 
 using System;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// 
+/// </summary>
+public static class RequestMetaDataExtensions
 {
 	/// <summary>
 	/// 
 	/// </summary>
-	public static class RequestMetaDataExtensions
+	/// <param name="metaData"></param>
+	/// <param name="helperValue"></param>
+	/// <exception cref="InvalidOperationException"></exception>
+	public static void AddHelper(this RequestMetaData metaData, string helperValue)
 	{
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="metaData"></param>
-		/// <param name="helperValue"></param>
-		/// <exception cref="InvalidOperationException"></exception>
-		public static void AddHelper(this RequestMetaData metaData, string helperValue)
-		{
-			if (!metaData.TryAddMetaData(RequestMetaData.HelperKey, helperValue))
-				throw new InvalidOperationException("A helper value has already been added.");
-		}
+		if (!metaData.TryAddMetaData(RequestMetaData.HelperKey, helperValue))
+			throw new InvalidOperationException("A helper value has already been added.");
 	}
-
 }
+
diff --git a/src/Elastic.Transport/Requests/MetaData/RuntimeVersionInfo.cs b/src/Elastic.Transport/Requests/MetaData/RuntimeVersionInfo.cs
index f6fca3a..290600f 100644
--- a/src/Elastic.Transport/Requests/MetaData/RuntimeVersionInfo.cs
+++ b/src/Elastic.Transport/Requests/MetaData/RuntimeVersionInfo.cs
@@ -35,210 +35,209 @@
 using System.Linq;
 #endif
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Represents the current .NET Runtime version.
+/// </summary>
+internal sealed class RuntimeVersionInfo : VersionInfo
 {
-	/// <summary>
-	/// Represents the current .NET Runtime version.
-	/// </summary>
-	internal sealed class RuntimeVersionInfo : VersionInfo
-	{
-		public static readonly RuntimeVersionInfo Default = new RuntimeVersionInfo { Version = new Version(0, 0, 0), IsPrerelease = false };
+	public static readonly RuntimeVersionInfo Default = new RuntimeVersionInfo { Version = new Version(0, 0, 0), IsPrerelease = false };
 
-		public RuntimeVersionInfo() => StoreVersion(GetRuntimeVersion());
+	public RuntimeVersionInfo() => StoreVersion(GetRuntimeVersion());
 
-		private static string GetRuntimeVersion() =>
+	private static string GetRuntimeVersion() =>
 #if !DOTNETCORE
-			GetFullFrameworkRuntime();
+		GetFullFrameworkRuntime();
 #else
-			GetNetCoreVersion();
+		GetNetCoreVersion();
 #endif
 
 #if DOTNETCORE
-		private static string GetNetCoreVersion()
+	private static string GetNetCoreVersion()
+	{
+		// for .NET 5+ we can use Environment.Version
+		if (Environment.Version.Major >= 5)
 		{
-			// for .NET 5+ we can use Environment.Version
-			if (Environment.Version.Major >= 5)
-			{
-				const string dotNet = ".NET ";
-				var index = RuntimeInformation.FrameworkDescription.IndexOf(dotNet, StringComparison.OrdinalIgnoreCase);
-				if (index >= 0)
-				{
-					return RuntimeInformation.FrameworkDescription.Substring(dotNet.Length);
-				}
-			}
-
-			// next, try using file version info
-			var systemPrivateCoreLib = FileVersionInfo.GetVersionInfo(typeof(object).Assembly.Location);
-			if (TryGetVersionFromProductInfo(systemPrivateCoreLib.ProductVersion, systemPrivateCoreLib.ProductName, out var runtimeVersion))
-			{
-				return runtimeVersion;
-			}
-
-			var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;
-			if (TryGetVersionFromAssemblyPath(assembly, out runtimeVersion))
+			const string dotNet = ".NET ";
+			var index = RuntimeInformation.FrameworkDescription.IndexOf(dotNet, StringComparison.OrdinalIgnoreCase);
+			if (index >= 0)
 			{
-				return runtimeVersion;
+				return RuntimeInformation.FrameworkDescription.Substring(dotNet.Length);
 			}
+		}
 
-			//At this point, we can't identify whether this is a prerelease, but a version is better than nothing!
-
-			var frameworkName = Assembly.GetEntryAssembly()?.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkName;
-			if (TryGetVersionFromFrameworkName(frameworkName, out runtimeVersion))
-			{
-				return runtimeVersion;
-			}
+		// next, try using file version info
+		var systemPrivateCoreLib = FileVersionInfo.GetVersionInfo(typeof(object).Assembly.Location);
+		if (TryGetVersionFromProductInfo(systemPrivateCoreLib.ProductVersion, systemPrivateCoreLib.ProductName, out var runtimeVersion))
+		{
+			return runtimeVersion;
+		}
 
-			if (IsRunningInContainer)
-			{
-				var dotNetVersion = Environment.GetEnvironmentVariable("DOTNET_VERSION");
-				var aspNetCoreVersion = Environment.GetEnvironmentVariable("ASPNETCORE_VERSION");
+		var assembly = typeof(System.Runtime.GCSettings).GetTypeInfo().Assembly;
+		if (TryGetVersionFromAssemblyPath(assembly, out runtimeVersion))
+		{
+			return runtimeVersion;
+		}
 
-				return dotNetVersion ?? aspNetCoreVersion;
-			}
+		//At this point, we can't identify whether this is a prerelease, but a version is better than nothing!
 
-			return null;
+		var frameworkName = Assembly.GetEntryAssembly()?.GetCustomAttribute<TargetFrameworkAttribute>()?.FrameworkName;
+		if (TryGetVersionFromFrameworkName(frameworkName, out runtimeVersion))
+		{
+			return runtimeVersion;
 		}
 
-		private static bool TryGetVersionFromAssemblyPath(Assembly assembly, out string runtimeVersion)
+		if (IsRunningInContainer)
 		{
-			var assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
-			var netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");
-			if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)
-			{
-				runtimeVersion = assemblyPath[netCoreAppIndex + 1];
-				return true;
-			}
+			var dotNetVersion = Environment.GetEnvironmentVariable("DOTNET_VERSION");
+			var aspNetCoreVersion = Environment.GetEnvironmentVariable("ASPNETCORE_VERSION");
 
-			runtimeVersion = null;
-			return false;
+			return dotNetVersion ?? aspNetCoreVersion;
 		}
 
-		// NOTE: 5.0.1 FrameworkDescription returns .NET 5.0.1-servicing.20575.16, so we special case servicing as NOT prerelease
-		protected override bool ContainsPrerelease(string version) => base.ContainsPrerelease(version) && !version.Contains("-servicing");
+		return null;
+	}
 
-		// sample input:
-		// 2.0: 4.6.26614.01 @BuiltBy: dlab14-DDVSOWINAGE018 @Commit: a536e7eec55c538c94639cefe295aa672996bf9b, Microsoft .NET Framework
-		// 2.1: 4.6.27817.01 @BuiltBy: dlab14-DDVSOWINAGE101 @Branch: release/2.1 @SrcCode: https://github.com/dotnet/coreclr/tree/6f78fbb3f964b4f407a2efb713a186384a167e5c, Microsoft .NET Framework
-		// 2.2: 4.6.27817.03 @BuiltBy: dlab14-DDVSOWINAGE101 @Branch: release/2.2 @SrcCode: https://github.com/dotnet/coreclr/tree/ce1d090d33b400a25620c0145046471495067cc7, Microsoft .NET Framework
-		// 3.0: 3.0.0-preview8.19379.2+ac25be694a5385a6a1496db40de932df0689b742, Microsoft .NET Core
-		// 5.0: 5.0.0-alpha1.19413.7+0ecefa44c9d66adb8a997d5778dc6c246ad393a7, Microsoft .NET Core
-		private static bool TryGetVersionFromProductInfo(string productVersion, string productName, out string version)
+	private static bool TryGetVersionFromAssemblyPath(Assembly assembly, out string runtimeVersion)
+	{
+		var assemblyPath = assembly.Location.Split(new[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries);
+		var netCoreAppIndex = Array.IndexOf(assemblyPath, "Microsoft.NETCore.App");
+		if (netCoreAppIndex > 0 && netCoreAppIndex < assemblyPath.Length - 2)
 		{
-			if (string.IsNullOrEmpty(productVersion) || string.IsNullOrEmpty(productName))
-			{
-				version = null;
-				return false;
-			}
+			runtimeVersion = assemblyPath[netCoreAppIndex + 1];
+			return true;
+		}
 
-			// yes, .NET Core 2.X has a product name == .NET Framework...
-			if (productName.IndexOf(".NET Framework", StringComparison.OrdinalIgnoreCase) >= 0)
-			{
-				const string releaseVersionPrefix = "release/";
-				var releaseVersionIndex = productVersion.IndexOf(releaseVersionPrefix);
-				if (releaseVersionIndex > 0)
-				{
-					version = productVersion.Substring(releaseVersionIndex + releaseVersionPrefix.Length);
-					return true;
-				}
-			}
+		runtimeVersion = null;
+		return false;
+	}
 
-			// matches .NET Core and also .NET 5+
-			if (productName.IndexOf(".NET", StringComparison.OrdinalIgnoreCase) >= 0)
-			{
-				version = productVersion;
-				return true;
-			}
+	// NOTE: 5.0.1 FrameworkDescription returns .NET 5.0.1-servicing.20575.16, so we special case servicing as NOT prerelease
+	protected override bool ContainsPrerelease(string version) => base.ContainsPrerelease(version) && !version.Contains("-servicing");
 
+	// sample input:
+	// 2.0: 4.6.26614.01 @BuiltBy: dlab14-DDVSOWINAGE018 @Commit: a536e7eec55c538c94639cefe295aa672996bf9b, Microsoft .NET Framework
+	// 2.1: 4.6.27817.01 @BuiltBy: dlab14-DDVSOWINAGE101 @Branch: release/2.1 @SrcCode: https://github.com/dotnet/coreclr/tree/6f78fbb3f964b4f407a2efb713a186384a167e5c, Microsoft .NET Framework
+	// 2.2: 4.6.27817.03 @BuiltBy: dlab14-DDVSOWINAGE101 @Branch: release/2.2 @SrcCode: https://github.com/dotnet/coreclr/tree/ce1d090d33b400a25620c0145046471495067cc7, Microsoft .NET Framework
+	// 3.0: 3.0.0-preview8.19379.2+ac25be694a5385a6a1496db40de932df0689b742, Microsoft .NET Core
+	// 5.0: 5.0.0-alpha1.19413.7+0ecefa44c9d66adb8a997d5778dc6c246ad393a7, Microsoft .NET Core
+	private static bool TryGetVersionFromProductInfo(string productVersion, string productName, out string version)
+	{
+		if (string.IsNullOrEmpty(productVersion) || string.IsNullOrEmpty(productName))
+		{
 			version = null;
 			return false;
 		}
 
-		// sample input:
-		// .NETCoreApp,Version=v2.0
-		// .NETCoreApp,Version=v2.1
-		private static bool TryGetVersionFromFrameworkName(string frameworkName, out string runtimeVersion)
+		// yes, .NET Core 2.X has a product name == .NET Framework...
+		if (productName.IndexOf(".NET Framework", StringComparison.OrdinalIgnoreCase) >= 0)
 		{
-			const string versionPrefix = ".NETCoreApp,Version=v";
-			if (!string.IsNullOrEmpty(frameworkName) && frameworkName.StartsWith(versionPrefix))
+			const string releaseVersionPrefix = "release/";
+			var releaseVersionIndex = productVersion.IndexOf(releaseVersionPrefix);
+			if (releaseVersionIndex > 0)
 			{
-				runtimeVersion = frameworkName.Substring(versionPrefix.Length);
+				version = productVersion.Substring(releaseVersionIndex + releaseVersionPrefix.Length);
 				return true;
 			}
+		}
 
-			runtimeVersion = null;
-			return false;
+		// matches .NET Core and also .NET 5+
+		if (productName.IndexOf(".NET", StringComparison.OrdinalIgnoreCase) >= 0)
+		{
+			version = productVersion;
+			return true;
+		}
+
+		version = null;
+		return false;
+	}
+
+	// sample input:
+	// .NETCoreApp,Version=v2.0
+	// .NETCoreApp,Version=v2.1
+	private static bool TryGetVersionFromFrameworkName(string frameworkName, out string runtimeVersion)
+	{
+		const string versionPrefix = ".NETCoreApp,Version=v";
+		if (!string.IsNullOrEmpty(frameworkName) && frameworkName.StartsWith(versionPrefix))
+		{
+			runtimeVersion = frameworkName.Substring(versionPrefix.Length);
+			return true;
 		}
 
-		private static bool IsRunningInContainer => string.Equals(Environment.GetEnvironmentVariable("DOTNET_RUNNING_IN_CONTAINER"), "true");
+		runtimeVersion = null;
+		return false;
+	}
+
+	private static bool IsRunningInContainer => string.Equals(Environment.GetEnvironmentVariable("DOTNET_RUNNING_IN_CONTAINER"), "true");
 #endif
 
 #if !DOTNETCORE
-		private static string GetFullFrameworkRuntime()
-		{
-			const string subkey = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\";
+	private static string GetFullFrameworkRuntime()
+	{
+		const string subkey = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full\";
 
-			using (var ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey(subkey))
+		using (var ndpKey = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry32).OpenSubKey(subkey))
+		{
+			if (ndpKey != null && ndpKey.GetValue("Release") != null)
 			{
-				if (ndpKey != null && ndpKey.GetValue("Release") != null)
-				{
-					var version = CheckFor45PlusVersion((int)ndpKey.GetValue("Release"));
+				var version = CheckFor45PlusVersion((int)ndpKey.GetValue("Release"));
 
-					if (!string.IsNullOrEmpty(version) )
-						return version;
-				}
+				if (!string.IsNullOrEmpty(version) )
+					return version;
 			}
+		}
 
-			var fullName = RuntimeInformation.FrameworkDescription;
-			var servicingVersion = new string(fullName.SkipWhile(c => !char.IsDigit(c)).ToArray());
-			var servicingVersionRelease = MapToReleaseVersion(servicingVersion);
+		var fullName = RuntimeInformation.FrameworkDescription;
+		var servicingVersion = new string(fullName.SkipWhile(c => !char.IsDigit(c)).ToArray());
+		var servicingVersionRelease = MapToReleaseVersion(servicingVersion);
 
-			return servicingVersionRelease;
+		return servicingVersionRelease;
 
-			static string MapToReleaseVersion(string servicingVersion)
-			{
-				// the following code assumes that .NET 4.6.1 is the oldest supported version
-				if (string.Compare(servicingVersion, "4.6.2") < 0)
-					return "4.6.1";
-				if (string.Compare(servicingVersion, "4.7") < 0)
-					return "4.6.2";
-				if (string.Compare(servicingVersion, "4.7.1") < 0)
-					return "4.7";
-				if (string.Compare(servicingVersion, "4.7.2") < 0)
-					return "4.7.1";
-				if (string.Compare(servicingVersion, "4.8") < 0)
-					return "4.7.2";
-
-				return "4.8.0"; // most probably the last major release of Full .NET Framework
-			}
+		static string MapToReleaseVersion(string servicingVersion)
+		{
+			// the following code assumes that .NET 4.6.1 is the oldest supported version
+			if (string.Compare(servicingVersion, "4.6.2") < 0)
+				return "4.6.1";
+			if (string.Compare(servicingVersion, "4.7") < 0)
+				return "4.6.2";
+			if (string.Compare(servicingVersion, "4.7.1") < 0)
+				return "4.7";
+			if (string.Compare(servicingVersion, "4.7.2") < 0)
+				return "4.7.1";
+			if (string.Compare(servicingVersion, "4.8") < 0)
+				return "4.7.2";
+
+			return "4.8.0"; // most probably the last major release of Full .NET Framework
+		}
 
-			// Checking the version using >= enables forward compatibility.
-			static string CheckFor45PlusVersion(int releaseKey)
-			{
-				if (releaseKey >= 528040)
-					return "4.8.0";
-				if (releaseKey >= 461808)
-					return "4.7.2";
-				if (releaseKey >= 461308)
-					return "4.7.1";
-				if (releaseKey >= 460798)
-					return "4.7";
-				if (releaseKey >= 394802)
-					return "4.6.2";
-				if (releaseKey >= 394254)
-					return "4.6.1";
-				if (releaseKey >= 393295)
-					return "4.6";
-				if (releaseKey >= 379893)
-					return "4.5.2";
-				if (releaseKey >= 378675)
-					return "4.5.1";
-				if (releaseKey >= 378389)
-					return "4.5.0";
-				// This code should never execute. A non-null release key should mean
-				// that 4.5 or later is installed.
-				return null;
-			}
+		// Checking the version using >= enables forward compatibility.
+		static string CheckFor45PlusVersion(int releaseKey)
+		{
+			if (releaseKey >= 528040)
+				return "4.8.0";
+			if (releaseKey >= 461808)
+				return "4.7.2";
+			if (releaseKey >= 461308)
+				return "4.7.1";
+			if (releaseKey >= 460798)
+				return "4.7";
+			if (releaseKey >= 394802)
+				return "4.6.2";
+			if (releaseKey >= 394254)
+				return "4.6.1";
+			if (releaseKey >= 393295)
+				return "4.6";
+			if (releaseKey >= 379893)
+				return "4.5.2";
+			if (releaseKey >= 378675)
+				return "4.5.1";
+			if (releaseKey >= 378389)
+				return "4.5.0";
+			// This code should never execute. A non-null release key should mean
+			// that 4.5 or later is installed.
+			return null;
 		}
-#endif
 	}
+#endif
 }
diff --git a/src/Elastic.Transport/Requests/MetaData/VersionInfo.cs b/src/Elastic.Transport/Requests/MetaData/VersionInfo.cs
index 8e52ca5..6f79d56 100644
--- a/src/Elastic.Transport/Requests/MetaData/VersionInfo.cs
+++ b/src/Elastic.Transport/Requests/MetaData/VersionInfo.cs
@@ -5,75 +5,74 @@
 using System;
 using System.Linq;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// 
+/// </summary>
+public abstract class VersionInfo
 {
 	/// <summary>
 	/// 
 	/// </summary>
-	public abstract class VersionInfo
-	{
-		/// <summary>
-		/// 
-		/// </summary>
-		protected const string EmptyVersion = "0.0.0";
+	protected const string EmptyVersion = "0.0.0";
 
-		/// <summary>
-		/// 
-		/// </summary>
-		public Version Version { get; protected set; }
+	/// <summary>
+	/// 
+	/// </summary>
+	public Version Version { get; protected set; }
 
-		/// <summary>
-		/// 
-		/// </summary>
-		public bool IsPrerelease { get; protected set; }
+	/// <summary>
+	/// 
+	/// </summary>
+	public bool IsPrerelease { get; protected set; }
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="fullVersion"></param>
-		/// <exception cref="ArgumentException"></exception>
-		protected void StoreVersion(string fullVersion)
-		{
-			if (string.IsNullOrEmpty(fullVersion))
-				fullVersion = EmptyVersion;
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="fullVersion"></param>
+	/// <exception cref="ArgumentException"></exception>
+	protected void StoreVersion(string fullVersion)
+	{
+		if (string.IsNullOrEmpty(fullVersion))
+			fullVersion = EmptyVersion;
 
-			var clientVersion = GetParsableVersionPart(fullVersion);
+		var clientVersion = GetParsableVersionPart(fullVersion);
 
-			if (!Version.TryParse(clientVersion, out var parsedVersion))
-				throw new ArgumentException("Invalid version string", nameof(fullVersion));
+		if (!Version.TryParse(clientVersion, out var parsedVersion))
+			throw new ArgumentException("Invalid version string", nameof(fullVersion));
 
-			var finalVersion = parsedVersion;
+		var finalVersion = parsedVersion;
 
-			if (parsedVersion.Minor == -1 || parsedVersion.Build == -1)
-				finalVersion = new Version(parsedVersion.Major, parsedVersion.Minor > -1
-					? parsedVersion.Minor
-					: 0, parsedVersion.Build > -1
-						? parsedVersion.Build
-						: 0);
+		if (parsedVersion.Minor == -1 || parsedVersion.Build == -1)
+			finalVersion = new Version(parsedVersion.Major, parsedVersion.Minor > -1
+				? parsedVersion.Minor
+				: 0, parsedVersion.Build > -1
+					? parsedVersion.Build
+					: 0);
 
-			Version = finalVersion;
-			IsPrerelease = ContainsPrerelease(fullVersion);
-		}
+		Version = finalVersion;
+		IsPrerelease = ContainsPrerelease(fullVersion);
+	}
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="version"></param>
-		/// <returns></returns>
-		protected virtual bool ContainsPrerelease(string version) => version.Contains("-");
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="version"></param>
+	/// <returns></returns>
+	protected virtual bool ContainsPrerelease(string version) => version.Contains("-");
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <param name="fullVersionName"></param>
-		/// <returns></returns>
-		private static string GetParsableVersionPart(string fullVersionName) =>
-			new(fullVersionName.TakeWhile(c => char.IsDigit(c) || c == '.').ToArray());
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="fullVersionName"></param>
+	/// <returns></returns>
+	private static string GetParsableVersionPart(string fullVersionName) =>
+		new(fullVersionName.TakeWhile(c => char.IsDigit(c) || c == '.').ToArray());
 
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <returns></returns>
-		public override string ToString() => IsPrerelease ? Version.ToString() + "p" : Version.ToString();
-	}
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <returns></returns>
+	public override string ToString() => IsPrerelease ? Version.ToString() + "p" : Version.ToString();
 }
diff --git a/src/Elastic.Transport/Requests/RequestParameters.cs b/src/Elastic.Transport/Requests/RequestParameters.cs
index f40e452..be4d0ad 100644
--- a/src/Elastic.Transport/Requests/RequestParameters.cs
+++ b/src/Elastic.Transport/Requests/RequestParameters.cs
@@ -6,115 +6,129 @@
 using static Elastic.Transport.UrlFormatter;
 
 // ReSharper disable once CheckNamespace
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// 
+/// </summary>
+public interface IStringable
 {
 	/// <summary>
 	/// 
 	/// </summary>
-	public interface IStringable
-	{
-		/// <summary>
-		/// 
-		/// </summary>
-		/// <returns></returns>
-		string GetString();
-	}
+	/// <returns></returns>
+	string GetString();
+}
 
-	/// <inheritdoc cref="IRequestParameters"/>
-	public class RequestParameters : RequestParameters<RequestParameters>
-	{
-	}
+/// <summary>
+/// 
+/// </summary>
+public sealed class DefaultRequestParameters : RequestParameters
+{
+}
 
+/// <summary>
+/// Used by the raw client to compose querystring parameters in a matter that still exposes some xmldocs
+/// You can always pass a simple NameValueCollection if you want.
+/// </summary>
+public abstract class RequestParameters
+{
 	/// <summary>
-	/// Used by the raw client to compose querystring parameters in a matter that still exposes some xmldocs
-	/// You can always pass a simple NameValueCollection if you want.
+	/// 
 	/// </summary>
-	/// <typeparam name="T"></typeparam>
-	public abstract class RequestParameters<T> : IRequestParameters where T : RequestParameters<T>
-	{
-		/// <inheritdoc cref="IRequestParameters.CustomResponseBuilder"/>
-		public CustomResponseBuilder CustomResponseBuilder { get; set; }
+	public CustomResponseBuilder CustomResponseBuilder { get; internal set; }
 
-		/// <inheritdoc cref="IRequestParameters.QueryString"/>
-		public Dictionary<string, object> QueryString { get; set; } = new Dictionary<string, object>();
+	/// <summary>
+	/// 
+	/// </summary>
+	public Dictionary<string, object> QueryString { get; internal set; } = new Dictionary<string, object>();
 
-		/// <inheritdoc cref="IRequestParameters.RequestConfiguration"/>
-		public IRequestConfiguration RequestConfiguration { get; set; }
+	/// <summary>
+	/// 
+	/// </summary>
+	public IRequestConfiguration RequestConfiguration { get; set; }
 
-		private IRequestParameters Self => this;
+	/// <summary>
+	/// 
+	/// </summary>
+	public bool ContainsQueryString(string name) => QueryString != null && QueryString.ContainsKey(name);
 
-		/// <inheritdoc />
-		public bool ContainsQueryString(string name) => Self.QueryString != null && Self.QueryString.ContainsKey(name);
+	/// <summary>
+	/// 
+	/// </summary>
+	public TOut GetQueryStringValue<TOut>(string name)
+	{
+		if (!ContainsQueryString(name))
+			return default;
 
-		/// <inheritdoc />
-		public TOut GetQueryStringValue<TOut>(string name)
-		{
-			if (!ContainsQueryString(name))
-				return default;
+		var value = QueryString[name];
+		if (value == null)
+			return default;
 
-			var value = Self.QueryString[name];
-			if (value == null)
-				return default;
+		return (TOut)value;
+	}
 
-			return (TOut)value;
-		}
+	/// <summary>
+	/// 
+	/// </summary>
+	public string GetResolvedQueryStringValue(string name, ITransportConfiguration transportConfiguration) =>
+		CreateString(GetQueryStringValue<object>(name), transportConfiguration);
 
-		/// <inheritdoc />
-		public string GetResolvedQueryStringValue(string name, ITransportConfiguration transportConfiguration) =>
-			CreateString(GetQueryStringValue<object>(name), transportConfiguration);
+	/// <summary>
+	/// 
+	/// </summary>
+	public void SetQueryString(string name, object value)
+	{
+		if (value == null) RemoveQueryString(name);
+		else QueryString[name] = value;
+	}
 
-		/// <inheritdoc />
-		public void SetQueryString(string name, object value)
-		{
-			if (value == null) RemoveQueryString(name);
-			else Self.QueryString[name] = value;
-		}
+	/// <summary> Shortcut to <see cref="GetQueryStringValue{TOut}"/> for generated code </summary>
+	protected TOut Q<TOut>(string name) => GetQueryStringValue<TOut>(name);
 
-		/// <summary> Shortcut to <see cref="GetQueryStringValue{TOut}"/> for generated code </summary>
-		protected TOut Q<TOut>(string name) => GetQueryStringValue<TOut>(name);
+	/// <summary> Shortcut to <see cref="SetQueryString"/> for generated code </summary>
+	protected void Q(string name, object value) => SetQueryString(name, value);
 
-		/// <summary> Shortcut to <see cref="SetQueryString"/> for generated code </summary>
-		protected void Q(string name, object value) => SetQueryString(name, value);
+	/// <summary> Shortcut to <see cref="SetQueryString"/> for generated code </summary>
+	protected void Q(string name, IStringable value) => SetQueryString(name, value.GetString());
 
-		/// <summary> Shortcut to <see cref="SetQueryString"/> for generated code </summary>
-		protected void Q(string name, IStringable value) => SetQueryString(name, value.GetString());
+	private void RemoveQueryString(string name)
+	{
+		if (!QueryString.ContainsKey(name)) return;
 
-		private void RemoveQueryString(string name)
-		{
-			if (!Self.QueryString.ContainsKey(name)) return;
+		QueryString.Remove(name);
+	}
 
-			Self.QueryString.Remove(name);
-		}
+	/// <summary>
+	/// Makes sure <see cref="RequestConfiguration"/> is set before explicitly setting <see cref="IRequestConfiguration.Accept"/>
+	/// </summary>
+	protected void SetAcceptHeader(string format)
+	{
+		if (RequestConfiguration == null)
+			RequestConfiguration = new RequestConfiguration();
 
-		/// <summary>
-		/// Makes sure <see cref="RequestConfiguration"/> is set before explicitly setting <see cref="IRequestConfiguration.Accept"/>
-		/// </summary>
-		protected void SetAcceptHeader(string format)
-		{
-			if (RequestConfiguration == null)
-				RequestConfiguration = new RequestConfiguration();
+		RequestConfiguration.Accept = AcceptHeaderFromFormat(format);
+	}
 
-			RequestConfiguration.Accept = AcceptHeaderFromFormat(format);
-		}
+	/// <summary>
+	/// 
+	/// </summary>
+	public string AcceptHeaderFromFormat(string format)
+	{
+		if (format == null)
+			return null;
+
+		var lowerFormat = format.ToLowerInvariant();
 
-		/// <inheritdoc />
-		public string AcceptHeaderFromFormat(string format)
+		switch(lowerFormat)
 		{
-			if (format == null)
+			case "smile":
+			case "yaml":
+			case "cbor":
+			case "json":
+				return $"application/{lowerFormat}";
+			default:
 				return null;
-
-			var lowerFormat = format.ToLowerInvariant();
-
-			switch(lowerFormat)
-			{
-				case "smile":
-				case "yaml":
-				case "cbor":
-				case "json":
-					return $"application/{lowerFormat}";
-				default:
-					return null;
-			}
 		}
 	}
 }
diff --git a/src/Elastic.Transport/Requests/UrlFormatter.cs b/src/Elastic.Transport/Requests/UrlFormatter.cs
index e85b8b5..79c2809 100644
--- a/src/Elastic.Transport/Requests/UrlFormatter.cs
+++ b/src/Elastic.Transport/Requests/UrlFormatter.cs
@@ -7,59 +7,58 @@
 using System.Linq;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A formatter that can utilize <see cref="ITransportConfiguration" /> to resolve <see cref="IUrlParameter" />'s passed
+/// as format arguments. It also handles known string representations for e.g bool/Enums/IEnumerable.
+/// </summary>
+public sealed class UrlFormatter : IFormatProvider, ICustomFormatter
 {
-	/// <summary>
-	/// A formatter that can utilize <see cref="ITransportConfiguration" /> to resolve <see cref="IUrlParameter" />'s passed
-	/// as format arguments. It also handles known string representations for e.g bool/Enums/IEnumerable.
-	/// </summary>
-	public sealed class UrlFormatter : IFormatProvider, ICustomFormatter
-	{
-		private readonly ITransportConfiguration _settings;
+	private readonly ITransportConfiguration _settings;
 
-		/// <inheritdoc cref="UrlFormatter"/>
-		public UrlFormatter(ITransportConfiguration settings) => _settings = settings;
+	/// <inheritdoc cref="UrlFormatter"/>
+	public UrlFormatter(ITransportConfiguration settings) => _settings = settings;
 
-		/// <inheritdoc cref="ICustomFormatter.Format"/>>
-		public string Format(string format, object arg, IFormatProvider formatProvider)
-		{
-			if (arg == null) throw new ArgumentNullException();
+	/// <inheritdoc cref="ICustomFormatter.Format"/>>
+	public string Format(string format, object arg, IFormatProvider formatProvider)
+	{
+		if (arg == null) throw new ArgumentNullException();
 
-			if (format == "r") return arg.ToString();
+		if (format == "r") return arg.ToString();
 
-			var value = CreateString(arg, _settings);
-			if (value.IsNullOrEmpty() && !format.IsNullOrEmpty())
-				throw new ArgumentException($"The parameter: {format} to the url is null or empty");
+		var value = CreateString(arg, _settings);
+		if (value.IsNullOrEmpty() && !format.IsNullOrEmpty())
+			throw new ArgumentException($"The parameter: {format} to the url is null or empty");
 
-			return value.IsNullOrEmpty() ? string.Empty : Uri.EscapeDataString(value);
-		}
+		return value.IsNullOrEmpty() ? string.Empty : Uri.EscapeDataString(value);
+	}
 
-		/// <inheritdoc cref="IFormatProvider.GetFormat"/>
-		public object GetFormat(Type formatType) => formatType == typeof(ICustomFormatter) ? this : null;
+	/// <inheritdoc cref="IFormatProvider.GetFormat"/>
+	public object GetFormat(Type formatType) => formatType == typeof(ICustomFormatter) ? this : null;
 
-		/// <inheritdoc cref="CreateString(object, ITransportConfiguration)"/>
-		public string CreateString(object value) => CreateString(value, _settings);
+	/// <inheritdoc cref="CreateString(object, ITransportConfiguration)"/>
+	public string CreateString(object value) => CreateString(value, _settings);
 
-		/// <summary> Creates a query string representation for <paramref name="value"/> </summary>
-		public static string CreateString(object value, ITransportConfiguration settings)
+	/// <summary> Creates a query string representation for <paramref name="value"/> </summary>
+	public static string CreateString(object value, ITransportConfiguration settings)
+	{
+		switch (value)
 		{
-			switch (value)
-			{
-				case null: return null;
-				case string s: return s;
-				case string[] ss: return string.Join(",", ss);
-				case Enum e: return e.GetStringValue();
-				case bool b: return b ? "true" : "false";
-				case DateTimeOffset offset: return offset.ToString("o");
-				case IEnumerable<object> pns:
-					return string.Join(",", pns.Select(o => ResolveUrlParameterOrDefault(o, settings)));
-				case TimeSpan timeSpan: return timeSpan.ToTimeUnit();
-				default:
-					return ResolveUrlParameterOrDefault(value, settings);
-			}
+			case null: return null;
+			case string s: return s;
+			case string[] ss: return string.Join(",", ss);
+			case Enum e: return e.GetStringValue();
+			case bool b: return b ? "true" : "false";
+			case DateTimeOffset offset: return offset.ToString("o");
+			case IEnumerable<object> pns:
+				return string.Join(",", pns.Select(o => ResolveUrlParameterOrDefault(o, settings)));
+			case TimeSpan timeSpan: return timeSpan.ToTimeUnit();
+			default:
+				return ResolveUrlParameterOrDefault(value, settings);
 		}
-
-		private static string ResolveUrlParameterOrDefault(object value, ITransportConfiguration settings) =>
-			value is IUrlParameter urlParam ? urlParam.GetString(settings) : value.ToString();
 	}
+
+	private static string ResolveUrlParameterOrDefault(object value, ITransportConfiguration settings) =>
+		value is IUrlParameter urlParam ? urlParam.GetString(settings) : value.ToString();
 }
diff --git a/src/Elastic.Transport/Responses/CustomResponseBuilder.cs b/src/Elastic.Transport/Responses/CustomResponseBuilder.cs
index 0161388..49383df 100644
--- a/src/Elastic.Transport/Responses/CustomResponseBuilder.cs
+++ b/src/Elastic.Transport/Responses/CustomResponseBuilder.cs
@@ -6,19 +6,18 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Allows callers of <see cref="HttpTransport.Request{TResponse}"/> to override completely
+/// how `TResponse` should be deserialized to a `TResponse` that implements <see cref="TransportResponse"/> instance.
+/// <para>Expert setting only</para>
+/// </summary>
+public abstract class CustomResponseBuilder
 {
-	/// <summary>
-	/// Allows callers of <see cref="ITransport.Request{TResponse}"/> to override completely
-	/// how `TResponse` should be deserialized to a `TResponse` that implements <see cref="ITransportResponse"/> instance.
-	/// <para>Expert setting only</para>
-	/// </summary>
-	public abstract class CustomResponseBuilder
-	{
-		/// <summary> Custom routine that deserializes from <paramref name="stream"/> to an instance of <see cref="ITransportResponse"/>.</summary>
-		public abstract object DeserializeResponse(Serializer builtInSerializer, IApiCallDetails response, Stream stream);
+	/// <summary> Custom routine that deserializes from <paramref name="stream"/> to an instance of <see cref="TransportResponse"/>.</summary>
+	public abstract object DeserializeResponse(Serializer serializer, ApiCallDetails response, Stream stream);
 
-		/// <inheritdoc cref="DeserializeResponse"/>
-		public abstract Task<object> DeserializeResponseAsync(Serializer builtInSerializer, IApiCallDetails response, Stream stream, CancellationToken ctx = default);
-	}
+	/// <inheritdoc cref="DeserializeResponse"/>
+	public abstract Task<object> DeserializeResponseAsync(Serializer serializer, ApiCallDetails response, Stream stream, CancellationToken ctx = default);
 }
diff --git a/src/Elastic.Transport/Responses/Dynamic/DynamicDictionary.cs b/src/Elastic.Transport/Responses/Dynamic/DynamicDictionary.cs
index a5999aa..7bad3ff 100644
--- a/src/Elastic.Transport/Responses/Dynamic/DynamicDictionary.cs
+++ b/src/Elastic.Transport/Responses/Dynamic/DynamicDictionary.cs
@@ -19,352 +19,351 @@
 // ReSharper disable RemoveRedundantBraces
 // ReSharper disable ArrangeAccessorOwnerBody
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A dictionary that supports dynamic access.
+/// </summary>
+public sealed class DynamicDictionary
+	: DynamicObject,
+		IEquatable<DynamicDictionary>,
+		IDictionary<string, DynamicValue>
 {
+	private readonly IDictionary<string, DynamicValue> _backingDictionary = new Dictionary<string, DynamicValue>(StringComparer.OrdinalIgnoreCase);
+
 	/// <summary>
-	/// A dictionary that supports dynamic access.
+	/// Gets the number of elements contained in the <see cref="DynamicDictionary" />.
 	/// </summary>
-	public sealed class DynamicDictionary
-		: DynamicObject,
-			IEquatable<DynamicDictionary>,
-			IDictionary<string, DynamicValue>
+	/// <returns>The number of elements contained in the <see cref="DynamicDictionary" />.</returns>
+	public int Count => _backingDictionary.Count;
+
+	/// <summary>
+	/// Creates a new instance of Dictionary{String,Object} using the keys and underlying object values of this DynamicDictionary instance's key values.
+	/// </summary>
+	/// <returns></returns>
+	public Dictionary<string, object> ToDictionary() =>
+		_backingDictionary.ToDictionary(kv => kv.Key, kv => kv.Value.Value is JsonElement e ? DynamicValue.ConsumeJsonElement(typeof(object), e) : kv.Value.Value);
+
+	/// <summary>
+	/// Returns an empty dynamic dictionary.
+	/// </summary>
+	/// <value>A <see cref="DynamicDictionary" /> instance.</value>
+	public static DynamicDictionary Empty => new DynamicDictionary();
+
+	/// <summary>
+	/// Gets a value indicating whether the <see cref="DynamicDictionary" /> is read-only.
+	/// </summary>
+	/// <returns>Always returns <see langword="false" />.</returns>
+	public bool IsReadOnly => false;
+
+	private static readonly Regex SplitRegex = new(@"(?<!\\)\.");
+
+	/// <summary>
+	/// Traverses data using path notation.
+	/// <para><c>e.g some.deep.nested.json.path</c></para>
+	/// <para></para>
+	/// <para> A special lookup is available for ANY key <c>_arbitrary_key_</c> <c>e.g some.deep._arbitrary_key_.json.path</c> which will traverse into the first key</para>
+	/// <para> If <c>_arbitrary_key_</c> is the last value it will return the key name</para>
+	/// <para></para>
+	/// </summary>
+	/// <param name="path">path into the stored object, keys are separated with a dot and the last key is returned as T</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>T or default</returns>
+	public T Get<T>(string path)
 	{
-		private readonly IDictionary<string, DynamicValue> _backingDictionary = new Dictionary<string, DynamicValue>(StringComparer.OrdinalIgnoreCase);
-
-		/// <summary>
-		/// Gets the number of elements contained in the <see cref="DynamicDictionary" />.
-		/// </summary>
-		/// <returns>The number of elements contained in the <see cref="DynamicDictionary" />.</returns>
-		public int Count => _backingDictionary.Count;
-
-		/// <summary>
-		/// Creates a new instance of Dictionary{String,Object} using the keys and underlying object values of this DynamicDictionary instance's key values.
-		/// </summary>
-		/// <returns></returns>
-		public Dictionary<string, object> ToDictionary() =>
-			_backingDictionary.ToDictionary(kv => kv.Key, kv => kv.Value.Value is JsonElement e ? DynamicValue.ConsumeJsonElement(typeof(object), e) : kv.Value.Value);
-
-		/// <summary>
-		/// Returns an empty dynamic dictionary.
-		/// </summary>
-		/// <value>A <see cref="DynamicDictionary" /> instance.</value>
-		public static DynamicDictionary Empty => new DynamicDictionary();
-
-		/// <summary>
-		/// Gets a value indicating whether the <see cref="DynamicDictionary" /> is read-only.
-		/// </summary>
-		/// <returns>Always returns <see langword="false" />.</returns>
-		public bool IsReadOnly => false;
-
-		private static readonly Regex SplitRegex = new(@"(?<!\\)\.");
-
-		/// <summary>
-		/// Traverses data using path notation.
-		/// <para><c>e.g some.deep.nested.json.path</c></para>
-		/// <para></para>
-		/// <para> A special lookup is available for ANY key <c>_arbitrary_key_</c> <c>e.g some.deep._arbitrary_key_.json.path</c> which will traverse into the first key</para>
-		/// <para> If <c>_arbitrary_key_</c> is the last value it will return the key name</para>
-		/// <para></para>
-		/// </summary>
-		/// <param name="path">path into the stored object, keys are separated with a dot and the last key is returned as T</param>
-		/// <typeparam name="T"></typeparam>
-		/// <returns>T or default</returns>
-		public T Get<T>(string path)
-		{
-			if (path == null) return default;
+		if (path == null) return default;
 
-			var split = SplitRegex.Split(path);
-			var queue = new Queue<string>(split);
-			if (queue.Count == 0) return default;
+		var split = SplitRegex.Split(path);
+		var queue = new Queue<string>(split);
+		if (queue.Count == 0) return default;
 
-			var d = new DynamicValue(_backingDictionary);
-			while (queue.Count > 0)
+		var d = new DynamicValue(_backingDictionary);
+		while (queue.Count > 0)
+		{
+			var key = queue.Dequeue().Replace(@"\.", ".");
+			if (key == "_arbitrary_key_")
 			{
-				var key = queue.Dequeue().Replace(@"\.", ".");
-				if (key == "_arbitrary_key_")
+				if (queue.Count > 0) d = d[0];
+				else
 				{
-					if (queue.Count > 0) d = d[0];
-					else
-					{
-						var v = d?.ToDictionary()?.Keys.FirstOrDefault();
-						d = v != null ? new DynamicValue(v) : DynamicValue.NullValue;
-					}
+					var v = d?.ToDictionary()?.Keys.FirstOrDefault();
+					d = v != null ? new DynamicValue(v) : DynamicValue.NullValue;
 				}
-				else if (int.TryParse(key, out var i)) d = d[i];
-				else d = d[key];
 			}
-
-			return d.TryParse<T>();
+			else if (int.TryParse(key, out var i)) d = d[i];
+			else d = d[key];
 		}
 
-		/// <summary>
-		/// Gets or sets the <see cref="DynamicValue" /> with the specified name.
-		/// </summary>
-		/// <value>A <see cref="DynamicValue" /> instance containing a value.</value>
-		public DynamicValue this[string name]
-		{
-			get
-			{
-				name = GetNeutralKey(name);
+		return d.TryParse<T>();
+	}
 
-				if (!_backingDictionary.TryGetValue(name, out var member))
-				{
-					member = new DynamicValue(null);
-				}
+	/// <summary>
+	/// Gets or sets the <see cref="DynamicValue" /> with the specified name.
+	/// </summary>
+	/// <value>A <see cref="DynamicValue" /> instance containing a value.</value>
+	public DynamicValue this[string name]
+	{
+		get
+		{
+			name = GetNeutralKey(name);
 
-				return member;
-			}
-			set
+			if (!_backingDictionary.TryGetValue(name, out var member))
 			{
-				name = GetNeutralKey(name);
-
-				_backingDictionary[name] = value ?? DynamicValue.NullValue;
+				member = new DynamicValue(null);
 			}
-		}
 
-		/// <summary>
-		/// Gets an <see cref="T:System.Collections.Generic.ICollection`1" /> containing the keys of the <see cref="DynamicDictionary" />.
-		/// </summary>
-		/// <returns>An <see cref="T:System.Collections.Generic.ICollection`1" /> containing the keys of the <see cref="DynamicDictionary" />.</returns>
-		public ICollection<string> Keys => _backingDictionary.Keys;
-
-		/// <summary>
-		/// Gets an <see cref="T:System.Collections.Generic.ICollection`1" /> containing the values in the <see cref="DynamicDictionary" />.
-		/// </summary>
-		/// <returns>An <see cref="T:System.Collections.Generic.ICollection`1" /> containing the values in the <see cref="DynamicDictionary" />.</returns>
-		public ICollection<DynamicValue> Values => _backingDictionary.Values;
-
-		/// <summary>
-		/// Adds an item to the <see cref="DynamicDictionary" />.
-		/// </summary>
-		/// <param name="item">The object to add to the <see cref="DynamicDictionary" />.</param>
-		public void Add(KeyValuePair<string, DynamicValue> item) => this[item.Key] = item.Value;
-
-		/// <summary>
-		/// Removes all items from the <see cref="DynamicDictionary" />.
-		/// </summary>
-		public void Clear() => _backingDictionary.Clear();
-
-		/// <summary>
-		/// Determines whether the <see cref="DynamicDictionary" /> contains a specific value.
-		/// </summary>
-		/// <returns>
-		/// <see langword="true" /> if <paramref name="item" /> is found in the <see cref="DynamicDictionary" />; otherwise, <see langword="false" />.
-		/// </returns>
-		/// <param name="item">The object to locate in the <see cref="DynamicDictionary" />.</param>
-		public bool Contains(KeyValuePair<string, DynamicValue> item) => _backingDictionary.Contains(item);
-
-		/// <summary>
-		/// Copies the elements of the <see cref="DynamicDictionary" /> to an <see cref="T:System.Array" />, starting at a particular
-		/// <see cref="T:System.Array" /> index.
-		/// </summary>
-		/// <param name="array">
-		/// The one-dimensional <see cref="T:System.Array" /> that is the destination of the elements copied from the
-		/// <see cref="DynamicDictionary" />. The <see cref="T:System.Array" /> must have zero-based indexing.
-		/// </param>
-		/// <param name="arrayIndex">The zero-based index in <paramref name="array" /> at which copying begins.</param>
-		public void CopyTo(KeyValuePair<string, DynamicValue>[] array, int arrayIndex) => _backingDictionary.CopyTo(array, arrayIndex);
-
-		/// <summary>
-		/// Removes the first occurrence of a specific object from the <see cref="DynamicDictionary" />.
-		/// </summary>
-		/// <returns>
-		/// <see langword="true" /> if <paramref name="item" /> was successfully removed from the <see cref="DynamicDictionary" />; otherwise,
-		/// <see langword="false" />.
-		/// </returns>
-		/// <param name="item">The object to remove from the <see cref="DynamicDictionary" />.</param>
-		public bool Remove(KeyValuePair<string, DynamicValue> item) => _backingDictionary.Remove(item);
-
-		/// <summary>
-		/// Adds an element with the provided key and value to the <see cref="DynamicDictionary" />.
-		/// </summary>
-		/// <param name="key">The object to use as the key of the element to add.</param>
-		/// <param name="value">The object to use as the value of the element to add.</param>
-		public void Add(string key, DynamicValue value) => this[key] = value;
-
-		/// <summary>
-		/// Determines whether the <see cref="DynamicDictionary" /> contains an element with the specified key.
-		/// </summary>
-		/// <returns>
-		/// <see langword="true" /> if the <see cref="DynamicDictionary" /> contains an element with the key; otherwise, <see langword="false" />.
-		/// </returns>
-		/// <param name="key">The key to locate in the <see cref="DynamicDictionary" />.</param>
-		public bool ContainsKey(string key) => _backingDictionary.ContainsKey(key);
-
-		/// <summary>
-		/// Removes the element with the specified key from the <see cref="DynamicDictionary" />.
-		/// </summary>
-		/// <returns><see langword="true" /> if the element is successfully removed; otherwise, <see langword="false" />.</returns>
-		/// <param name="key">The key of the element to remove.</param>
-		public bool Remove(string key)
-		{
-			key = GetNeutralKey(key);
-			return _backingDictionary.Remove(key);
+			return member;
 		}
-
-		/// <summary>
-		/// Gets the value associated with the specified key.
-		/// </summary>
-		/// <returns>
-		/// <see langword="true" /> if the <see cref="DynamicDictionary" /> contains an element with the specified key; otherwise,
-		/// <see langword="false" />.
-		/// </returns>
-		/// <param name="key">The key whose value to get.</param>
-		/// <param name="value">
-		/// When this method returns, the value associated with the specified key, if the key is found; otherwise, the default
-		/// value for the type of the <paramref name="value" /> parameter. This parameter is passed uninitialized.
-		/// </param>
-		public bool TryGetValue(string key, out DynamicValue value)
+		set
 		{
-			if (_backingDictionary.TryGetValue(key, out value)) return true;
+			name = GetNeutralKey(name);
 
-			return false;
+			_backingDictionary[name] = value ?? DynamicValue.NullValue;
 		}
+	}
 
-		/// <summary>
-		/// Returns the enumeration of all dynamic member names.
-		/// </summary>
-		/// <returns>A <see cref="IEnumerator" /> that contains dynamic member names.</returns>
-		IEnumerator IEnumerable.GetEnumerator() => _backingDictionary.GetEnumerator();
-
-		/// <summary>
-		/// Returns an enumerator that iterates through the collection.
-		/// </summary>
-		/// <returns>A <see cref="T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.</returns>
-		IEnumerator<KeyValuePair<string, DynamicValue>> IEnumerable<KeyValuePair<string, DynamicValue>>.GetEnumerator() => _backingDictionary.GetEnumerator();
-
-		/// <summary>
-		/// Indicates whether the current <see cref="DynamicDictionary" /> is equal to another object of the same type.
-		/// </summary>
-		/// <returns>
-		/// <see langword="true" /> if the current instance is equal to the <paramref name="other" /> parameter; otherwise,
-		/// <see langword="false" />.
-		/// </returns>
-		/// <param name="other">An <see cref="DynamicDictionary" /> instance to compare with this instance.</param>
-		public bool Equals(DynamicDictionary other)
-		{
-			if (ReferenceEquals(null, other))
-			{
-				return false;
-			}
+	/// <summary>
+	/// Gets an <see cref="T:System.Collections.Generic.ICollection`1" /> containing the keys of the <see cref="DynamicDictionary" />.
+	/// </summary>
+	/// <returns>An <see cref="T:System.Collections.Generic.ICollection`1" /> containing the keys of the <see cref="DynamicDictionary" />.</returns>
+	public ICollection<string> Keys => _backingDictionary.Keys;
 
-			return ReferenceEquals(this, other) || Equals(other._backingDictionary, _backingDictionary);
-		}
+	/// <summary>
+	/// Gets an <see cref="T:System.Collections.Generic.ICollection`1" /> containing the values in the <see cref="DynamicDictionary" />.
+	/// </summary>
+	/// <returns>An <see cref="T:System.Collections.Generic.ICollection`1" /> containing the values in the <see cref="DynamicDictionary" />.</returns>
+	public ICollection<DynamicValue> Values => _backingDictionary.Values;
 
-		/// <summary>
-		/// Creates a dynamic dictionary from an <see cref="IDictionary{TKey,TValue}" /> instance.
-		/// </summary>
-		/// <param name="values">An <see cref="IDictionary{TKey,TValue}" /> instance, that the dynamic dictionary should be created from.</param>
-		/// <returns>An <see cref="DynamicDictionary" /> instance.</returns>
-		public static DynamicDictionary Create(IDictionary<string, object> values)
-		{
-			var instance = new DynamicDictionary();
+	/// <summary>
+	/// Adds an item to the <see cref="DynamicDictionary" />.
+	/// </summary>
+	/// <param name="item">The object to add to the <see cref="DynamicDictionary" />.</param>
+	public void Add(KeyValuePair<string, DynamicValue> item) => this[item.Key] = item.Value;
 
-			foreach (var key in values.Keys)
-			{
-				var v = values[key];
-				instance[key] = v is DynamicValue av ? av : new DynamicValue(v);
-			}
+	/// <summary>
+	/// Removes all items from the <see cref="DynamicDictionary" />.
+	/// </summary>
+	public void Clear() => _backingDictionary.Clear();
 
-			return instance;
-		}
-		/// <summary>
-		/// Creates a dynamic dictionary from an <see cref="JsonElement" /> instance.
-		/// </summary>
-		public static DynamicDictionary Create(JsonElement e)
+	/// <summary>
+	/// Determines whether the <see cref="DynamicDictionary" /> contains a specific value.
+	/// </summary>
+	/// <returns>
+	/// <see langword="true" /> if <paramref name="item" /> is found in the <see cref="DynamicDictionary" />; otherwise, <see langword="false" />.
+	/// </returns>
+	/// <param name="item">The object to locate in the <see cref="DynamicDictionary" />.</param>
+	public bool Contains(KeyValuePair<string, DynamicValue> item) => _backingDictionary.Contains(item);
+
+	/// <summary>
+	/// Copies the elements of the <see cref="DynamicDictionary" /> to an <see cref="T:System.Array" />, starting at a particular
+	/// <see cref="T:System.Array" /> index.
+	/// </summary>
+	/// <param name="array">
+	/// The one-dimensional <see cref="T:System.Array" /> that is the destination of the elements copied from the
+	/// <see cref="DynamicDictionary" />. The <see cref="T:System.Array" /> must have zero-based indexing.
+	/// </param>
+	/// <param name="arrayIndex">The zero-based index in <paramref name="array" /> at which copying begins.</param>
+	public void CopyTo(KeyValuePair<string, DynamicValue>[] array, int arrayIndex) => _backingDictionary.CopyTo(array, arrayIndex);
+
+	/// <summary>
+	/// Removes the first occurrence of a specific object from the <see cref="DynamicDictionary" />.
+	/// </summary>
+	/// <returns>
+	/// <see langword="true" /> if <paramref name="item" /> was successfully removed from the <see cref="DynamicDictionary" />; otherwise,
+	/// <see langword="false" />.
+	/// </returns>
+	/// <param name="item">The object to remove from the <see cref="DynamicDictionary" />.</param>
+	public bool Remove(KeyValuePair<string, DynamicValue> item) => _backingDictionary.Remove(item);
+
+	/// <summary>
+	/// Adds an element with the provided key and value to the <see cref="DynamicDictionary" />.
+	/// </summary>
+	/// <param name="key">The object to use as the key of the element to add.</param>
+	/// <param name="value">The object to use as the value of the element to add.</param>
+	public void Add(string key, DynamicValue value) => this[key] = value;
+
+	/// <summary>
+	/// Determines whether the <see cref="DynamicDictionary" /> contains an element with the specified key.
+	/// </summary>
+	/// <returns>
+	/// <see langword="true" /> if the <see cref="DynamicDictionary" /> contains an element with the key; otherwise, <see langword="false" />.
+	/// </returns>
+	/// <param name="key">The key to locate in the <see cref="DynamicDictionary" />.</param>
+	public bool ContainsKey(string key) => _backingDictionary.ContainsKey(key);
+
+	/// <summary>
+	/// Removes the element with the specified key from the <see cref="DynamicDictionary" />.
+	/// </summary>
+	/// <returns><see langword="true" /> if the element is successfully removed; otherwise, <see langword="false" />.</returns>
+	/// <param name="key">The key of the element to remove.</param>
+	public bool Remove(string key)
+	{
+		key = GetNeutralKey(key);
+		return _backingDictionary.Remove(key);
+	}
+
+	/// <summary>
+	/// Gets the value associated with the specified key.
+	/// </summary>
+	/// <returns>
+	/// <see langword="true" /> if the <see cref="DynamicDictionary" /> contains an element with the specified key; otherwise,
+	/// <see langword="false" />.
+	/// </returns>
+	/// <param name="key">The key whose value to get.</param>
+	/// <param name="value">
+	/// When this method returns, the value associated with the specified key, if the key is found; otherwise, the default
+	/// value for the type of the <paramref name="value" /> parameter. This parameter is passed uninitialized.
+	/// </param>
+	public bool TryGetValue(string key, out DynamicValue value)
+	{
+		if (_backingDictionary.TryGetValue(key, out value)) return true;
+
+		return false;
+	}
+
+	/// <summary>
+	/// Returns the enumeration of all dynamic member names.
+	/// </summary>
+	/// <returns>A <see cref="IEnumerator" /> that contains dynamic member names.</returns>
+	IEnumerator IEnumerable.GetEnumerator() => _backingDictionary.GetEnumerator();
+
+	/// <summary>
+	/// Returns an enumerator that iterates through the collection.
+	/// </summary>
+	/// <returns>A <see cref="T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.</returns>
+	IEnumerator<KeyValuePair<string, DynamicValue>> IEnumerable<KeyValuePair<string, DynamicValue>>.GetEnumerator() => _backingDictionary.GetEnumerator();
+
+	/// <summary>
+	/// Indicates whether the current <see cref="DynamicDictionary" /> is equal to another object of the same type.
+	/// </summary>
+	/// <returns>
+	/// <see langword="true" /> if the current instance is equal to the <paramref name="other" /> parameter; otherwise,
+	/// <see langword="false" />.
+	/// </returns>
+	/// <param name="other">An <see cref="DynamicDictionary" /> instance to compare with this instance.</param>
+	public bool Equals(DynamicDictionary other)
+	{
+		if (ReferenceEquals(null, other))
 		{
-			var dict = e.ToDictionary();
-			return dict == null ? Empty : Create(dict);
+			return false;
 		}
 
-		/// <summary>
-		/// Provides the implementation for operations that set member values. Classes derived from the <see cref="T:System.Dynamic.DynamicObject" />
-		/// class can override this method to specify dynamic behavior for operations such as setting a value for a property.
-		/// </summary>
-		/// <returns>
-		/// true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language
-		/// determines the behavior. (In most cases, a language-specific run-time exception is thrown.)
-		/// </returns>
-		/// <param name="binder">
-		/// Provides information about the object that called the dynamic operation. The binder.Name property provides the name of
-		/// the member to which the value is being assigned. For example, for the statement sampleObject.SampleProperty = "Test", where sampleObject is
-		/// an instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject" /> class, binder.Name returns "SampleProperty". The
-		/// binder.IgnoreCase property specifies whether the member name is case-sensitive.
-		/// </param>
-		/// <param name="value">
-		/// The value to set to the member. For example, for sampleObject.SampleProperty = "Test", where sampleObject is an
-		/// instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject" /> class, the <paramref name="value" /> is "Test".
-		/// </param>
-		public override bool TrySetMember(SetMemberBinder binder, object value)
+		return ReferenceEquals(this, other) || Equals(other._backingDictionary, _backingDictionary);
+	}
+
+	/// <summary>
+	/// Creates a dynamic dictionary from an <see cref="IDictionary{TKey,TValue}" /> instance.
+	/// </summary>
+	/// <param name="values">An <see cref="IDictionary{TKey,TValue}" /> instance, that the dynamic dictionary should be created from.</param>
+	/// <returns>An <see cref="DynamicDictionary" /> instance.</returns>
+	public static DynamicDictionary Create(IDictionary<string, object> values)
+	{
+		var instance = new DynamicDictionary();
+
+		foreach (var key in values.Keys)
 		{
-			this[binder.Name] = new DynamicValue(value);
-			return true;
+			var v = values[key];
+			instance[key] = v is DynamicValue av ? av : new DynamicValue(v);
 		}
 
-		/// <summary>
-		/// Provides the implementation for operations that get member values. Classes derived from the <see cref="T:System.Dynamic.DynamicObject" />
-		/// class can override this method to specify dynamic behavior for operations such as getting a value for a property.
-		/// </summary>
-		/// <returns>
-		/// true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language
-		/// determines the behavior. (In most cases, a run-time exception is thrown.)
-		/// </returns>
-		/// <param name="binder">
-		/// Provides information about the object that called the dynamic operation. The binder.Name property provides the name of
-		/// the member on which the dynamic operation is performed. For example, for the Console.WriteLine(sampleObject.SampleProperty) statement,
-		/// where sampleObject is an instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject" /> class, binder.Name returns
-		/// "SampleProperty". The binder.IgnoreCase property specifies whether the member name is case-sensitive.
-		/// </param>
-		/// <param name="result">
-		/// The result of the get operation. For example, if the method is called for a property, you can assign the property
-		/// value to <paramref name="result" />.
-		/// </param>
-		public override bool TryGetMember(GetMemberBinder binder, out object result)
-		{
-			if (!_backingDictionary.TryGetValue(binder.Name, out var v))
-			{
-				result = new DynamicValue(null);
-			}
-			else result = v;
+		return instance;
+	}
+	/// <summary>
+	/// Creates a dynamic dictionary from an <see cref="JsonElement" /> instance.
+	/// </summary>
+	public static DynamicDictionary Create(JsonElement e)
+	{
+		var dict = e.ToDictionary();
+		return dict == null ? Empty : Create(dict);
+	}
 
-			return true;
-		}
+	/// <summary>
+	/// Provides the implementation for operations that set member values. Classes derived from the <see cref="T:System.Dynamic.DynamicObject" />
+	/// class can override this method to specify dynamic behavior for operations such as setting a value for a property.
+	/// </summary>
+	/// <returns>
+	/// true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language
+	/// determines the behavior. (In most cases, a language-specific run-time exception is thrown.)
+	/// </returns>
+	/// <param name="binder">
+	/// Provides information about the object that called the dynamic operation. The binder.Name property provides the name of
+	/// the member to which the value is being assigned. For example, for the statement sampleObject.SampleProperty = "Test", where sampleObject is
+	/// an instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject" /> class, binder.Name returns "SampleProperty". The
+	/// binder.IgnoreCase property specifies whether the member name is case-sensitive.
+	/// </param>
+	/// <param name="value">
+	/// The value to set to the member. For example, for sampleObject.SampleProperty = "Test", where sampleObject is an
+	/// instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject" /> class, the <paramref name="value" /> is "Test".
+	/// </param>
+	public override bool TrySetMember(SetMemberBinder binder, object value)
+	{
+		this[binder.Name] = new DynamicValue(value);
+		return true;
+	}
 
-		/// <summary>
-		/// Returns the enumeration of all dynamic member names.
-		/// </summary>
-		/// <returns>A <see cref="IEnumerable{T}" /> that contains dynamic member names.</returns>
-		public override IEnumerable<string> GetDynamicMemberNames() => _backingDictionary.Keys;
-
-		/// <summary>
-		/// Determines whether the specified <see cref="object" /> is equal to this instance.
-		/// </summary>
-		/// <param name="obj">The <see cref="object" /> to compare with this instance.</param>
-		/// <returns>
-		/// <see langword="true" /> if the specified <see cref="object" /> is equal to this instance; otherwise,
-		/// <see langword="false" />.
-		/// </returns>
-		public override bool Equals(object obj)
+	/// <summary>
+	/// Provides the implementation for operations that get member values. Classes derived from the <see cref="T:System.Dynamic.DynamicObject" />
+	/// class can override this method to specify dynamic behavior for operations such as getting a value for a property.
+	/// </summary>
+	/// <returns>
+	/// true if the operation is successful; otherwise, false. If this method returns false, the run-time binder of the language
+	/// determines the behavior. (In most cases, a run-time exception is thrown.)
+	/// </returns>
+	/// <param name="binder">
+	/// Provides information about the object that called the dynamic operation. The binder.Name property provides the name of
+	/// the member on which the dynamic operation is performed. For example, for the Console.WriteLine(sampleObject.SampleProperty) statement,
+	/// where sampleObject is an instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject" /> class, binder.Name returns
+	/// "SampleProperty". The binder.IgnoreCase property specifies whether the member name is case-sensitive.
+	/// </param>
+	/// <param name="result">
+	/// The result of the get operation. For example, if the method is called for a property, you can assign the property
+	/// value to <paramref name="result" />.
+	/// </param>
+	public override bool TryGetMember(GetMemberBinder binder, out object result)
+	{
+		if (!_backingDictionary.TryGetValue(binder.Name, out var v))
 		{
-			if (ReferenceEquals(null, obj))
-			{
-				return false;
-			}
+			result = new DynamicValue(null);
+		}
+		else result = v;
 
-			if (ReferenceEquals(this, obj))
-			{
-				return true;
-			}
+		return true;
+	}
+
+	/// <summary>
+	/// Returns the enumeration of all dynamic member names.
+	/// </summary>
+	/// <returns>A <see cref="IEnumerable{T}" /> that contains dynamic member names.</returns>
+	public override IEnumerable<string> GetDynamicMemberNames() => _backingDictionary.Keys;
 
-			return obj.GetType() == typeof(DynamicDictionary) && Equals((DynamicDictionary)obj);
+	/// <summary>
+	/// Determines whether the specified <see cref="object" /> is equal to this instance.
+	/// </summary>
+	/// <param name="obj">The <see cref="object" /> to compare with this instance.</param>
+	/// <returns>
+	/// <see langword="true" /> if the specified <see cref="object" /> is equal to this instance; otherwise,
+	/// <see langword="false" />.
+	/// </returns>
+	public override bool Equals(object obj)
+	{
+		if (ReferenceEquals(null, obj))
+		{
+			return false;
 		}
 
-		/// <summary>
-		/// Returns a hash code for this <see cref="DynamicDictionary" />.
-		/// </summary>
-		/// <returns> A hash code for this <see cref="DynamicDictionary" />, suitable for use in hashing algorithms and data structures like a hash table.</returns>
-		public override int GetHashCode() => _backingDictionary?.GetHashCode() ?? 0;
+		if (ReferenceEquals(this, obj))
+		{
+			return true;
+		}
 
-		private static string GetNeutralKey(string key) => key;
+		return obj.GetType() == typeof(DynamicDictionary) && Equals((DynamicDictionary)obj);
 	}
+
+	/// <summary>
+	/// Returns a hash code for this <see cref="DynamicDictionary" />.
+	/// </summary>
+	/// <returns> A hash code for this <see cref="DynamicDictionary" />, suitable for use in hashing algorithms and data structures like a hash table.</returns>
+	public override int GetHashCode() => _backingDictionary?.GetHashCode() ?? 0;
+
+	private static string GetNeutralKey(string key) => key;
 }
diff --git a/src/Elastic.Transport/Responses/Dynamic/DynamicResponse.cs b/src/Elastic.Transport/Responses/Dynamic/DynamicResponse.cs
index 39586a9..6ff2a73 100644
--- a/src/Elastic.Transport/Responses/Dynamic/DynamicResponse.cs
+++ b/src/Elastic.Transport/Responses/Dynamic/DynamicResponse.cs
@@ -4,39 +4,38 @@
 
 using System.Dynamic;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A type of response that makes it easier to work with responses in an untyped fashion.
+///
+/// <para>It exposes the body as <see cref="DynamicDictionary"/> which is `dynamic` through <see cref="DynamicObject"/></para>
+/// <para></para>
+/// <para>Since `dynamic` can be scary in .NET this response also exposes a safe traversal mechanism under
+/// <see cref="Get{T}"/> which support an xpath'esque syntax to fish for values in the returned json.
+/// </para>
+/// </summary>
+public sealed class DynamicResponse : TransportResponse<DynamicDictionary>
 {
-	/// <summary>
-	/// A type of response that makes it easier to work with responses in an untyped fashion.
-	///
-	/// <para>It exposes the body as <see cref="DynamicDictionary"/> which is `dynamic` through <see cref="DynamicObject"/></para>
-	/// <para></para>
-	/// <para>Since `dynamic` can be scary in .NET this response also exposes a safe traversal mechanism under
-	/// <see cref="Get{T}"/> which support an xpath'esque syntax to fish for values in the returned json.
-	/// </para>
-	/// </summary>
-	public sealed class DynamicResponse : TransportResponse<DynamicDictionary>
-	{
-		/// <inheritdoc cref="DynamicResponse"/>
-		public DynamicResponse() { }
+	/// <inheritdoc cref="DynamicResponse"/>
+	public DynamicResponse() { }
 
-		/// <inheritdoc cref="DynamicResponse"/>
-		public DynamicResponse(DynamicDictionary dictionary)
-		{
-			Body = dictionary;
-			Dictionary = dictionary;
-		}
+	/// <inheritdoc cref="DynamicResponse"/>
+	public DynamicResponse(DynamicDictionary dictionary)
+	{
+		Body = dictionary;
+		Dictionary = dictionary;
+	}
 
-		private DynamicDictionary Dictionary { get; }
+	private DynamicDictionary Dictionary { get; }
 
-		/// <summary>
-		/// Traverses data using path notation.
-		/// <para><c>e.g some.deep.nested.json.path</c></para>
-		/// <para> A special lookup is available for ANY key using <c>_arbitrary_key_</c> <c>e.g some.deep._arbitrary_key_.json.path</c> which will traverse into the first key</para>
-		/// </summary>
-		/// <param name="path">path into the stored object, keys are separated with a dot and the last key is returned as T</param>
-		/// <typeparam name="T"></typeparam>
-		/// <returns>T or default</returns>
-		public T Get<T>(string path) => Dictionary.Get<T>(path);
-	}
+	/// <summary>
+	/// Traverses data using path notation.
+	/// <para><c>e.g some.deep.nested.json.path</c></para>
+	/// <para> A special lookup is available for ANY key using <c>_arbitrary_key_</c> <c>e.g some.deep._arbitrary_key_.json.path</c> which will traverse into the first key</para>
+	/// </summary>
+	/// <param name="path">path into the stored object, keys are separated with a dot and the last key is returned as T</param>
+	/// <typeparam name="T"></typeparam>
+	/// <returns>T or default</returns>
+	public T Get<T>(string path) => Dictionary.Get<T>(path);
 }
diff --git a/src/Elastic.Transport/Responses/Dynamic/DynamicValue.cs b/src/Elastic.Transport/Responses/Dynamic/DynamicValue.cs
index 1961cfa..8fda591 100644
--- a/src/Elastic.Transport/Responses/Dynamic/DynamicValue.cs
+++ b/src/Elastic.Transport/Responses/Dynamic/DynamicValue.cs
@@ -21,968 +21,967 @@
 // ReSharper disable RemoveRedundantBraces
 // ReSharper disable ArrangeMethodOrOperatorBody
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// Represents a value returned by <see cref="DynamicDictionary"/>.
+///
+/// <para>This is `dynamic` through <see cref="DynamicObject"/> and supports direct casting various valuetypes</para>
+/// <para>Since `dynamic` can be scary in .NET this response also exposes a safe traversal mechanism under
+/// <see cref="Get{T}"/> which support an xpath'esque syntax to fish for values in the returned json.
+/// </para>
+/// </summary>
+public sealed class DynamicValue : DynamicObject, IEquatable<DynamicValue>, IConvertible, IReadOnlyCollection<DynamicValue>
 {
+	private readonly object _value;
+
+	/// <summary>
+	/// Initializes a new instance of the <see cref="DynamicValue" /> class.
+	/// </summary>
+	/// <param name="value">The value to store in the instance</param>
+	public DynamicValue(object value) => _value = value is DynamicValue av ? av.Value : value;
+
+	/// <summary>
+	/// Gets a value indicating whether this instance has value.
+	/// </summary>
+	/// <value><c>true</c> if this instance has value; otherwise, <c>false</c>.</value>
+	/// <remarks><see langword="null" /> is considered as not being a value.</remarks>
+	public bool HasValue => _value != null;
+
 	/// <summary>
-	/// Represents a value returned by <see cref="DynamicDictionary"/>.
-	///
-	/// <para>This is `dynamic` through <see cref="DynamicObject"/> and supports direct casting various valuetypes</para>
-	/// <para>Since `dynamic` can be scary in .NET this response also exposes a safe traversal mechanism under
-	/// <see cref="Get{T}"/> which support an xpath'esque syntax to fish for values in the returned json.
-	/// </para>
+	/// Try to get key <paramref name="name"/> from the object this instance references
 	/// </summary>
-	public class DynamicValue : DynamicObject, IEquatable<DynamicValue>, IConvertible, IReadOnlyCollection<DynamicValue>
+	/// <param name="name"></param>
+	public DynamicValue this[string name]
 	{
-		private readonly object _value;
-
-		/// <summary>
-		/// Initializes a new instance of the <see cref="DynamicValue" /> class.
-		/// </summary>
-		/// <param name="value">The value to store in the instance</param>
-		public DynamicValue(object value) => _value = value is DynamicValue av ? av.Value : value;
-
-		/// <summary>
-		/// Gets a value indicating whether this instance has value.
-		/// </summary>
-		/// <value><c>true</c> if this instance has value; otherwise, <c>false</c>.</value>
-		/// <remarks><see langword="null" /> is considered as not being a value.</remarks>
-		public bool HasValue => _value != null;
-
-		/// <summary>
-		/// Try to get key <paramref name="name"/> from the object this instance references
-		/// </summary>
-		/// <param name="name"></param>
-		public DynamicValue this[string name]
-		{
-			get
-			{
-				Dispatch(out var r, name);
-				return (DynamicValue)r;
-			}
+		get
+		{
+			Dispatch(out var r, name);
+			return (DynamicValue)r;
 		}
+	}
 
-		/// <inheritdoc cref="DynamicDictionary.Get{T}"/>
-		public T Get<T>(string path)
+	/// <inheritdoc cref="DynamicDictionary.Get{T}"/>
+	public T Get<T>(string path)
+	{
+		var dynamicDictionary = Value switch
 		{
-			var dynamicDictionary = Value switch
-			{
-				DynamicDictionary v => v,
-				IDictionary<string, object> v => DynamicDictionary.Create(v),
-				JsonElement e => DynamicDictionary.Create(e),
-				_ => null
-			};
-			return dynamicDictionary == null ? default : dynamicDictionary.Get<T>(path);
-		}
+			DynamicDictionary v => v,
+			IDictionary<string, object> v => DynamicDictionary.Create(v),
+			JsonElement e => DynamicDictionary.Create(e),
+			_ => null
+		};
+		return dynamicDictionary == null ? default : dynamicDictionary.Get<T>(path);
+	}
 
-		/// <summary>
-		/// A static reusable reference to a <see cref="DynamicValue"/> holding `null` that is still safe to traverse
-		/// on through <see cref="Get{T}"/>
-		/// </summary>
-		public static DynamicValue NullValue { get; } = new DynamicValue(null);
-
-		/// <summary>
-		/// Wrap <paramref name="v"/> as a <see cref="DynamicValue"/> if <paramref name="v"/> is not wrapped already
-		/// </summary>
-		/// <param name="v"></param>
-		/// <returns></returns>
-		public static DynamicValue SelfOrNew(object v) => v is DynamicValue av ? av : new DynamicValue(v);
-
-		/// <summary>
-		/// Gets the inner value
-		/// </summary>
-		public object Value => _value;
-
-		/// <summary>
-		/// Returns the <see cref="T:System.TypeCode" /> for this instance.
-		/// </summary>
-		/// <returns>
-		/// The enumerated constant that is the <see cref="T:System.TypeCode" /> of the class or value type that implements this interface.
-		/// </returns>
-		/// <filterpriority>2</filterpriority>
-		public TypeCode GetTypeCode()
-		{
-			if (_value == null) return TypeCode.Empty;
-
-			return Type.GetTypeCode(_value.GetType());
-		}
+	/// <summary>
+	/// A static reusable reference to a <see cref="DynamicValue"/> holding `null` that is still safe to traverse
+	/// on through <see cref="Get{T}"/>
+	/// </summary>
+	public static DynamicValue NullValue { get; } = new DynamicValue(null);
 
-		/// <summary>
-		/// Converts the value of this instance to an equivalent Boolean value using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// A Boolean value equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public bool ToBoolean(IFormatProvider provider) => Convert.ToBoolean(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent 8-bit unsigned integer using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// An 8-bit unsigned integer equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public byte ToByte(IFormatProvider provider) => Convert.ToByte(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent Unicode character using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// A Unicode character equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public char ToChar(IFormatProvider provider) => Convert.ToChar(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent <see cref="T:System.DateTime" /> using the specified culture-specific formatting
-		/// information.
-		/// </summary>
-		/// <returns>
-		/// A <see cref="T:System.DateTime" /> instance equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public DateTime ToDateTime(IFormatProvider provider) => Convert.ToDateTime(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent <see cref="T:System.Decimal" /> number using the specified culture-specific formatting
-		/// information.
-		/// </summary>
-		/// <returns>
-		/// A <see cref="T:System.Decimal" /> number equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public decimal ToDecimal(IFormatProvider provider) => Convert.ToDecimal(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent double-precision floating-point number using the specified culture-specific formatting
-		/// information.
-		/// </summary>
-		/// <returns>
-		/// A double-precision floating-point number equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public double ToDouble(IFormatProvider provider) => Convert.ToDouble(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent 16-bit signed integer using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// An 16-bit signed integer equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public short ToInt16(IFormatProvider provider) => Convert.ToInt16(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent 32-bit signed integer using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// An 32-bit signed integer equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public int ToInt32(IFormatProvider provider) => Convert.ToInt32(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent 64-bit signed integer using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// An 64-bit signed integer equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public long ToInt64(IFormatProvider provider) => Convert.ToInt64(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent 8-bit signed integer using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// An 8-bit signed integer equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		[CLSCompliant(false)]
-		public sbyte ToSByte(IFormatProvider provider) => Convert.ToSByte(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent single-precision floating-point number using the specified culture-specific formatting
-		/// information.
-		/// </summary>
-		/// <returns>
-		/// A single-precision floating-point number equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public float ToSingle(IFormatProvider provider) => Convert.ToSingle(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent <see cref="T:System.String" /> using the specified culture-specific formatting
-		/// information.
-		/// </summary>
-		/// <returns>
-		/// A <see cref="T:System.String" /> instance equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public string ToString(IFormatProvider provider) => Convert.ToString(_value, provider)!;
-
-		/// <summary>
-		/// Converts the value of this instance to an <see cref="T:System.Object" /> of the specified <see cref="T:System.Type" /> that has an
-		/// equivalent value, using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// An <see cref="T:System.Object" /> instance of type <paramref name="conversionType" /> whose value is equivalent to the value of this
-		/// instance.
-		/// </returns>
-		/// <param name="conversionType">The <see cref="T:System.Type" /> to which the value of this instance is converted. </param>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		public object ToType(Type conversionType, IFormatProvider provider) => Convert.ChangeType(_value, conversionType, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent 16-bit unsigned integer using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// An 16-bit unsigned integer equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		[CLSCompliant(false)]
-		public ushort ToUInt16(IFormatProvider provider) => Convert.ToUInt16(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent 32-bit unsigned integer using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// An 32-bit unsigned integer equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		[CLSCompliant(false)]
-		public uint ToUInt32(IFormatProvider provider) => Convert.ToUInt32(_value, provider);
-
-		/// <summary>
-		/// Converts the value of this instance to an equivalent 64-bit unsigned integer using the specified culture-specific formatting information.
-		/// </summary>
-		/// <returns>
-		/// An 64-bit unsigned integer equivalent to the value of this instance.
-		/// </returns>
-		/// <param name="provider">
-		/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
-		/// information.
-		/// </param>
-		/// <filterpriority>2</filterpriority>
-		[CLSCompliant(false)]
-		public ulong ToUInt64(IFormatProvider provider) => Convert.ToUInt64(_value, provider);
-
-		/// <summary>
-		/// Returns the value as a dictionary if the current value represents an object.
-		/// Otherwise returns null.
-		/// </summary>
-		public IDictionary<string, DynamicValue> ToDictionary()
-		{
-			if (_value is IDictionary<string, object> dict) return DynamicDictionary.Create(dict);
-			else if (_value is JsonElement e && e.ValueKind == JsonValueKind.Object)
-			{
-				var d = e.EnumerateObject()
-					.Aggregate(new Dictionary<string, object>(), (dictionary, je) =>
-					{
-						dictionary.Add(je.Name, je.Value);
-						return dictionary;
-					});
-				return DynamicDictionary.Create(d);
-			}
+	/// <summary>
+	/// Wrap <paramref name="v"/> as a <see cref="DynamicValue"/> if <paramref name="v"/> is not wrapped already
+	/// </summary>
+	/// <param name="v"></param>
+	/// <returns></returns>
+	public static DynamicValue SelfOrNew(object v) => v is DynamicValue av ? av : new DynamicValue(v);
 
-			return null;
-		}
+	/// <summary>
+	/// Gets the inner value
+	/// </summary>
+	public object Value => _value;
 
+	/// <summary>
+	/// Returns the <see cref="T:System.TypeCode" /> for this instance.
+	/// </summary>
+	/// <returns>
+	/// The enumerated constant that is the <see cref="T:System.TypeCode" /> of the class or value type that implements this interface.
+	/// </returns>
+	/// <filterpriority>2</filterpriority>
+	public TypeCode GetTypeCode()
+	{
+		if (_value == null) return TypeCode.Empty;
 
-		/// <summary>
-		/// Indicates whether the current object is equal to another object of the same type.
-		/// </summary>
-		/// <returns>
-		/// <c>true</c> if the current object is equal to the <paramref name="compareValue" /> parameter; otherwise, <c>false</c>.
-		/// </returns>
-		/// <param name="compareValue">An <see cref="DynamicValue" /> to compare with this instance.</param>
-		public bool Equals(DynamicValue compareValue)
-		{
-			if (ReferenceEquals(null, compareValue))
-			{
-				return false;
-			}
+		return Type.GetTypeCode(_value.GetType());
+	}
 
-			return ReferenceEquals(this, compareValue) || Equals(compareValue._value, _value);
-		}
+	/// <summary>
+	/// Converts the value of this instance to an equivalent Boolean value using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// A Boolean value equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public bool ToBoolean(IFormatProvider provider) => Convert.ToBoolean(_value, provider);
 
-		/// <see cref="DynamicObject.TryGetMember"/>
-		public override bool TryGetMember(GetMemberBinder binder, out object result)
-		{
-			var name = binder.Name;
+	/// <summary>
+	/// Converts the value of this instance to an equivalent 8-bit unsigned integer using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// An 8-bit unsigned integer equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public byte ToByte(IFormatProvider provider) => Convert.ToByte(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent Unicode character using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// A Unicode character equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public char ToChar(IFormatProvider provider) => Convert.ToChar(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent <see cref="T:System.DateTime" /> using the specified culture-specific formatting
+	/// information.
+	/// </summary>
+	/// <returns>
+	/// A <see cref="T:System.DateTime" /> instance equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public DateTime ToDateTime(IFormatProvider provider) => Convert.ToDateTime(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent <see cref="T:System.Decimal" /> number using the specified culture-specific formatting
+	/// information.
+	/// </summary>
+	/// <returns>
+	/// A <see cref="T:System.Decimal" /> number equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public decimal ToDecimal(IFormatProvider provider) => Convert.ToDecimal(_value, provider);
 
-			return Dispatch(out result, name);
+	/// <summary>
+	/// Converts the value of this instance to an equivalent double-precision floating-point number using the specified culture-specific formatting
+	/// information.
+	/// </summary>
+	/// <returns>
+	/// A double-precision floating-point number equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public double ToDouble(IFormatProvider provider) => Convert.ToDouble(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent 16-bit signed integer using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// An 16-bit signed integer equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public short ToInt16(IFormatProvider provider) => Convert.ToInt16(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent 32-bit signed integer using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// An 32-bit signed integer equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public int ToInt32(IFormatProvider provider) => Convert.ToInt32(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent 64-bit signed integer using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// An 64-bit signed integer equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public long ToInt64(IFormatProvider provider) => Convert.ToInt64(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent 8-bit signed integer using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// An 8-bit signed integer equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	[CLSCompliant(false)]
+	public sbyte ToSByte(IFormatProvider provider) => Convert.ToSByte(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent single-precision floating-point number using the specified culture-specific formatting
+	/// information.
+	/// </summary>
+	/// <returns>
+	/// A single-precision floating-point number equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public float ToSingle(IFormatProvider provider) => Convert.ToSingle(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent <see cref="T:System.String" /> using the specified culture-specific formatting
+	/// information.
+	/// </summary>
+	/// <returns>
+	/// A <see cref="T:System.String" /> instance equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public string ToString(IFormatProvider provider) => Convert.ToString(_value, provider)!;
+
+	/// <summary>
+	/// Converts the value of this instance to an <see cref="T:System.Object" /> of the specified <see cref="T:System.Type" /> that has an
+	/// equivalent value, using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// An <see cref="T:System.Object" /> instance of type <paramref name="conversionType" /> whose value is equivalent to the value of this
+	/// instance.
+	/// </returns>
+	/// <param name="conversionType">The <see cref="T:System.Type" /> to which the value of this instance is converted. </param>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	public object ToType(Type conversionType, IFormatProvider provider) => Convert.ChangeType(_value, conversionType, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent 16-bit unsigned integer using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// An 16-bit unsigned integer equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	[CLSCompliant(false)]
+	public ushort ToUInt16(IFormatProvider provider) => Convert.ToUInt16(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent 32-bit unsigned integer using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// An 32-bit unsigned integer equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	[CLSCompliant(false)]
+	public uint ToUInt32(IFormatProvider provider) => Convert.ToUInt32(_value, provider);
+
+	/// <summary>
+	/// Converts the value of this instance to an equivalent 64-bit unsigned integer using the specified culture-specific formatting information.
+	/// </summary>
+	/// <returns>
+	/// An 64-bit unsigned integer equivalent to the value of this instance.
+	/// </returns>
+	/// <param name="provider">
+	/// An <see cref="T:System.IFormatProvider" /> interface implementation that supplies culture-specific formatting
+	/// information.
+	/// </param>
+	/// <filterpriority>2</filterpriority>
+	[CLSCompliant(false)]
+	public ulong ToUInt64(IFormatProvider provider) => Convert.ToUInt64(_value, provider);
+
+	/// <summary>
+	/// Returns the value as a dictionary if the current value represents an object.
+	/// Otherwise returns null.
+	/// </summary>
+	public IDictionary<string, DynamicValue> ToDictionary()
+	{
+		if (_value is IDictionary<string, object> dict) return DynamicDictionary.Create(dict);
+		else if (_value is JsonElement e && e.ValueKind == JsonValueKind.Object)
+		{
+			var d = e.EnumerateObject()
+				.Aggregate(new Dictionary<string, object>(), (dictionary, je) =>
+				{
+					dictionary.Add(je.Name, je.Value);
+					return dictionary;
+				});
+			return DynamicDictionary.Create(d);
 		}
 
+		return null;
+	}
+
 
-		private bool Dispatch(out object result, string name)
+	/// <summary>
+	/// Indicates whether the current object is equal to another object of the same type.
+	/// </summary>
+	/// <returns>
+	/// <c>true</c> if the current object is equal to the <paramref name="compareValue" /> parameter; otherwise, <c>false</c>.
+	/// </returns>
+	/// <param name="compareValue">An <see cref="DynamicValue" /> to compare with this instance.</param>
+	public bool Equals(DynamicValue compareValue)
+	{
+		if (ReferenceEquals(null, compareValue))
 		{
-			if (!HasValue)
-			{
-				result = NullValue;
-				return true;
-			}
+			return false;
+		}
 
-			if (Value is IDictionary<string, object> d)
-			{
-				result = d.TryGetValue(name, out var r) ? SelfOrNew(r) : NullValue;
-				return true;
-			}
-			if (Value is IDynamicMetaObjectProvider)
-			{
-				var dm = GetDynamicMember(Value, name);
-				result = SelfOrNew(dm);
-				return true;
-			}
-			if (Value is IDictionary ds)
-			{
-				result = ds.Contains(name) ? SelfOrNew(ds[name]) : NullValue;
-				return true;
-			}
-			if (Value is IList l)
-			{
-				var projected = l
-					.Cast<object>()
-					.Select(i => SelfOrNew(i).Dispatch(out var o, name) ? o : null)
-					.Where(i => i != null)
-					.ToArray();
-				result = SelfOrNew(projected);
-				return projected.Length > 0;
-			}
-			if (Value is IList<object> lo)
-			{
-				var projected = lo
-					.Select(i => SelfOrNew(i).Dispatch(out var o, name) ? o : null)
-					.Where(i => i != null)
-					.ToArray();
-				result = SelfOrNew(projected);
-				return projected.Length > 0;
-			}
-			if (Value is JsonElement e && e.ValueKind == JsonValueKind.Object)
-			{
-				if (e.TryGetProperty(name, out var r))
-				{
-					result = SelfOrNew(r);
-					return true;
-				}
-			}
-			if (Value is JsonElement a && a.ValueKind == JsonValueKind.Array)
-			{
-				var projected = a.EnumerateArray()
-					.Select(i => SelfOrNew(i).Dispatch(out var o, name) ? o : null)
-					.Where(i => i != null)
-					.ToArray();
-				result = SelfOrNew(projected);
-				return projected.Length > 0;
-			}
+		return ReferenceEquals(this, compareValue) || Equals(compareValue._value, _value);
+	}
 
+	/// <see cref="DynamicObject.TryGetMember"/>
+	public override bool TryGetMember(GetMemberBinder binder, out object result)
+	{
+		var name = binder.Name;
+
+		return Dispatch(out result, name);
+	}
+
+
+	private bool Dispatch(out object result, string name)
+	{
+		if (!HasValue)
+		{
 			result = NullValue;
 			return true;
 		}
 
-		private static object GetDynamicMember(object obj, string memberName)
+		if (Value is IDictionary<string, object> d)
 		{
-			var binder = Binder.GetMember(CSharpBinderFlags.None, memberName, null,
-				new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
-			var callsite = CallSite<Func<CallSite, object, object>>.Create(binder);
-			return callsite.Target(callsite, obj);
+			result = d.TryGetValue(name, out var r) ? SelfOrNew(r) : NullValue;
+			return true;
 		}
-
-		/// <summary>
-		/// Returns a default value if Value is null
-		/// </summary>
-		/// <typeparam name="T">When no default value is supplied, required to supply the default type</typeparam>
-		/// <param name="defaultValue">Optional parameter for default value, if not given it returns default of type T</param>
-		/// <returns>If value is not null, value is returned, else default value is returned</returns>
-		public T Default<T>(T defaultValue = default(T))
+		if (Value is IDynamicMetaObjectProvider)
+		{
+			var dm = GetDynamicMember(Value, name);
+			result = SelfOrNew(dm);
+			return true;
+		}
+		if (Value is IDictionary ds)
+		{
+			result = ds.Contains(name) ? SelfOrNew(ds[name]) : NullValue;
+			return true;
+		}
+		if (Value is IList l)
 		{
-			if (HasValue)
+			var projected = l
+				.Cast<object>()
+				.Select(i => SelfOrNew(i).Dispatch(out var o, name) ? o : null)
+				.Where(i => i != null)
+				.ToArray();
+			result = SelfOrNew(projected);
+			return projected.Length > 0;
+		}
+		if (Value is IList<object> lo)
+		{
+			var projected = lo
+				.Select(i => SelfOrNew(i).Dispatch(out var o, name) ? o : null)
+				.Where(i => i != null)
+				.ToArray();
+			result = SelfOrNew(projected);
+			return projected.Length > 0;
+		}
+		if (Value is JsonElement e && e.ValueKind == JsonValueKind.Object)
+		{
+			if (e.TryGetProperty(name, out var r))
 			{
-				try
-				{
-					return (T)_value;
-				}
-				catch
-				{
-					var typeName = _value.GetType().Name;
-					var message = string.Format("Cannot convert value of type '{0}' to type '{1}'",
-						typeName, typeof(T).Name);
-
-					throw new InvalidCastException(message);
-				}
+				result = SelfOrNew(r);
+				return true;
 			}
-
-			return defaultValue;
 		}
-
-		/// <summary>
-		/// Attempts to convert the value to type of T, failing to do so will return the defaultValue.
-		/// </summary>
-		/// <typeparam name="T">When no default value is supplied, required to supply the default type</typeparam>
-		/// <param name="defaultValue">Optional parameter for default value, if not given it returns default of type T</param>
-		/// <returns>If value is not null, value is returned, else default value is returned</returns>
-		public T TryParse<T>(T defaultValue = default)
+		if (Value is JsonElement a && a.ValueKind == JsonValueKind.Array)
 		{
-			if (!HasValue) return defaultValue;
+			var projected = a.EnumerateArray()
+				.Select(i => SelfOrNew(i).Dispatch(out var o, name) ? o : null)
+				.Where(i => i != null)
+				.ToArray();
+			result = SelfOrNew(projected);
+			return projected.Length > 0;
+		}
+
+		result = NullValue;
+		return true;
+	}
+
+	private static object GetDynamicMember(object obj, string memberName)
+	{
+		var binder = Binder.GetMember(CSharpBinderFlags.None, memberName, null,
+			new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
+		var callsite = CallSite<Func<CallSite, object, object>>.Create(binder);
+		return callsite.Target(callsite, obj);
+	}
 
+	/// <summary>
+	/// Returns a default value if Value is null
+	/// </summary>
+	/// <typeparam name="T">When no default value is supplied, required to supply the default type</typeparam>
+	/// <param name="defaultValue">Optional parameter for default value, if not given it returns default of type T</param>
+	/// <returns>If value is not null, value is returned, else default value is returned</returns>
+	public T Default<T>(T defaultValue = default(T))
+	{
+		if (HasValue)
+		{
 			try
 			{
-				return TryParse(defaultValue, typeof(T), _value, out var o) ? (T)o : defaultValue;
+				return (T)_value;
 			}
 			catch
 			{
-				return defaultValue;
+				var typeName = _value.GetType().Name;
+				var message = string.Format("Cannot convert value of type '{0}' to type '{1}'",
+					typeName, typeof(T).Name);
+
+				throw new InvalidCastException(message);
 			}
 		}
 
-#pragma warning disable 1591
-		public static object ConsumeJsonElement(Type targetReturnType, JsonElement e)
+		return defaultValue;
+	}
+
+	/// <summary>
+	/// Attempts to convert the value to type of T, failing to do so will return the defaultValue.
+	/// </summary>
+	/// <typeparam name="T">When no default value is supplied, required to supply the default type</typeparam>
+	/// <param name="defaultValue">Optional parameter for default value, if not given it returns default of type T</param>
+	/// <returns>If value is not null, value is returned, else default value is returned</returns>
+	public T TryParse<T>(T defaultValue = default)
+	{
+		if (!HasValue) return defaultValue;
+
+		try
 		{
-			// ReSharper disable once HeapView.BoxingAllocation
-			object ParseNumber(JsonElement el)
-			{
-				if (el.TryGetInt64(out var l))
-					return l;
+			return TryParse(defaultValue, typeof(T), _value, out var o) ? (T)o : defaultValue;
+		}
+		catch
+		{
+			return defaultValue;
+		}
+	}
 
-				return el.GetDouble();
-			}
+#pragma warning disable 1591
+	public static object ConsumeJsonElement(Type targetReturnType, JsonElement e)
+	{
+		// ReSharper disable once HeapView.BoxingAllocation
+		object ParseNumber(JsonElement el)
+		{
+			if (el.TryGetInt64(out var l))
+				return l;
 
-			return targetReturnType switch
-			{
-				_ when targetReturnType == typeof(bool) => e.GetBoolean(),
-				_ when targetReturnType == typeof(byte) => e.GetByte(),
-				_ when targetReturnType == typeof(decimal) => e.GetDecimal(),
-				_ when targetReturnType == typeof(double) => e.GetDouble(),
-				_ when targetReturnType == typeof(Guid) => e.GetGuid(),
-				_ when targetReturnType == typeof(short) => e.GetInt16(),
-				_ when targetReturnType == typeof(int) => e.GetInt32(),
-				_ when targetReturnType == typeof(long) => e.GetInt64(),
-				_ when targetReturnType == typeof(float) => e.GetSingle(),
-				_ when targetReturnType == typeof(string) => e.GetString(),
-				_ when targetReturnType == typeof(DateTime) => e.GetDateTime(),
-				_ when targetReturnType == typeof(DateTimeOffset) => e.GetDateTimeOffset(),
-				_ when targetReturnType == typeof(ushort) => e.GetUInt16(),
-				_ when targetReturnType == typeof(uint) => e.GetUInt32(),
-				_ when targetReturnType == typeof(ulong) => e.GetUInt64(),
-				_ when targetReturnType == typeof(sbyte) => e.GetSByte(),
-				_ when targetReturnType == typeof(DynamicDictionary) => DynamicDictionary.Create(e),
-				_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Array =>
-					e.EnumerateArray().Select(je => ConsumeJsonElement(targetReturnType, je)).ToArray(),
-				_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Object => e.ToDictionary(),
-				_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.True => true,
-				_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.False => false,
-				_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Null => null,
-				_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.String => e.GetString(),
-				_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Number => ParseNumber(e),
-				_ => null
-			};
+			return el.GetDouble();
 		}
 
-		internal bool TryParse(object defaultValue, Type targetReturnType, object value, out object newObject)
+		return targetReturnType switch
 		{
-			newObject = defaultValue;
-			if (value == null) return false;
+			_ when targetReturnType == typeof(bool) => e.GetBoolean(),
+			_ when targetReturnType == typeof(byte) => e.GetByte(),
+			_ when targetReturnType == typeof(decimal) => e.GetDecimal(),
+			_ when targetReturnType == typeof(double) => e.GetDouble(),
+			_ when targetReturnType == typeof(Guid) => e.GetGuid(),
+			_ when targetReturnType == typeof(short) => e.GetInt16(),
+			_ when targetReturnType == typeof(int) => e.GetInt32(),
+			_ when targetReturnType == typeof(long) => e.GetInt64(),
+			_ when targetReturnType == typeof(float) => e.GetSingle(),
+			_ when targetReturnType == typeof(string) => e.GetString(),
+			_ when targetReturnType == typeof(DateTime) => e.GetDateTime(),
+			_ when targetReturnType == typeof(DateTimeOffset) => e.GetDateTimeOffset(),
+			_ when targetReturnType == typeof(ushort) => e.GetUInt16(),
+			_ when targetReturnType == typeof(uint) => e.GetUInt32(),
+			_ when targetReturnType == typeof(ulong) => e.GetUInt64(),
+			_ when targetReturnType == typeof(sbyte) => e.GetSByte(),
+			_ when targetReturnType == typeof(DynamicDictionary) => DynamicDictionary.Create(e),
+			_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Array =>
+				e.EnumerateArray().Select(je => ConsumeJsonElement(targetReturnType, je)).ToArray(),
+			_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Object => e.ToDictionary(),
+			_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.True => true,
+			_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.False => false,
+			_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Null => null,
+			_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.String => e.GetString(),
+			_ when targetReturnType == typeof(object) && e.ValueKind == JsonValueKind.Number => ParseNumber(e),
+			_ => null
+		};
+	}
 
-			if (targetReturnType.IsGenericType && targetReturnType.GetGenericTypeDefinition() == typeof(Nullable<>))
-				targetReturnType = targetReturnType.GenericTypeArguments[0];
+	internal bool TryParse(object defaultValue, Type targetReturnType, object value, out object newObject)
+	{
+		newObject = defaultValue;
+		if (value == null) return false;
 
-			try
+		if (targetReturnType.IsGenericType && targetReturnType.GetGenericTypeDefinition() == typeof(Nullable<>))
+			targetReturnType = targetReturnType.GenericTypeArguments[0];
+
+		try
+		{
+			if (value is JsonElement e)
 			{
-				if (value is JsonElement e)
-				{
 
-					// ReSharper disable once HeapView.BoxingAllocation
-					newObject = ConsumeJsonElement(targetReturnType, e);
-					return true;
-				}
+				// ReSharper disable once HeapView.BoxingAllocation
+				newObject = ConsumeJsonElement(targetReturnType, e);
+				return true;
+			}
 
-				var valueType = value.GetType();
-				if (targetReturnType.IsArray && value is DynamicValue v)
-				{
-					value = v.Value;
-					valueType = value.GetType();
-				}
-				if (targetReturnType.IsArray)
+			var valueType = value.GetType();
+			if (targetReturnType.IsArray && value is DynamicValue v)
+			{
+				value = v.Value;
+				valueType = value.GetType();
+			}
+			if (targetReturnType.IsArray)
+			{
+				if (!valueType.IsArray)
 				{
-					if (!valueType.IsArray)
-					{
-						return false;
-					}
-					var ar = (object[])value;
-					var t = targetReturnType.GetElementType();
-					var objectArray = ar
-						.Select(a => TryParse(defaultValue, t, a, out var o) ? o : null)
-						.Where(a => a != null)
-						.ToArray();
-
-					var arr = Array.CreateInstance(t, objectArray.Length);
-					Array.Copy(objectArray, arr, objectArray.Length);
-					newObject = arr;
-					return true;
+					return false;
 				}
+				var ar = (object[])value;
+				var t = targetReturnType.GetElementType();
+				var objectArray = ar
+					.Select(a => TryParse(defaultValue, t, a, out var o) ? o : null)
+					.Where(a => a != null)
+					.ToArray();
 
-				if (valueType.IsAssignableFrom(targetReturnType))
-				{
-					newObject = value;
-					return true;
-				}
+				var arr = Array.CreateInstance(t, objectArray.Length);
+				Array.Copy(objectArray, arr, objectArray.Length);
+				newObject = arr;
+				return true;
+			}
 
-				var stringValue = value as string;
+			if (valueType.IsAssignableFrom(targetReturnType))
+			{
+				newObject = value;
+				return true;
+			}
 
-				if (targetReturnType == typeof(DateTime)
-					&& DateTime.TryParse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
-				{
-					newObject = result;
-					return true;
-				}
-				if (stringValue != null)
-				{
-					if (targetReturnType == typeof(object))
-					{
-						newObject = Convert.ChangeType(value, targetReturnType);
-						return true;
-					}
-
-					var converter = TypeDescriptor.GetConverter(targetReturnType);
-					if (converter.IsValid(stringValue))
-					{
-						newObject = converter.ConvertFromInvariantString(stringValue);
-						return true;
-					}
-				}
-				else if (value is DynamicValue dv)
-					return dv.TryParse(defaultValue, targetReturnType, dv.Value, out newObject);
-				else if (targetReturnType == typeof(string))
-				{
-					newObject = Convert.ChangeType(value, TypeCode.String, CultureInfo.InvariantCulture);
-					return true;
-				}
-				else if (valueType.IsValueType)
-				{
-					newObject = Convert.ChangeType(_value, targetReturnType);
-					return true;
-				}
-				else if (targetReturnType == typeof(DynamicDictionary) && valueType == typeof(Dictionary<string, object>))
+			var stringValue = value as string;
+
+			if (targetReturnType == typeof(DateTime)
+				&& DateTime.TryParse(stringValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out var result))
+			{
+				newObject = result;
+				return true;
+			}
+			if (stringValue != null)
+			{
+				if (targetReturnType == typeof(object))
 				{
-					newObject = DynamicDictionary.Create(value as Dictionary<string, object>);
+					newObject = Convert.ChangeType(value, targetReturnType);
 					return true;
 				}
 
-				else if (targetReturnType == typeof(object))
+				var converter = TypeDescriptor.GetConverter(targetReturnType);
+				if (converter.IsValid(stringValue))
 				{
-					newObject = value;
+					newObject = converter.ConvertFromInvariantString(stringValue);
 					return true;
 				}
 			}
-			catch
+			else if (value is DynamicValue dv)
+				return dv.TryParse(defaultValue, targetReturnType, dv.Value, out newObject);
+			else if (targetReturnType == typeof(string))
 			{
-				return false;
+				newObject = Convert.ChangeType(value, TypeCode.String, CultureInfo.InvariantCulture);
+				return true;
 			}
+			else if (valueType.IsValueType)
+			{
+				newObject = Convert.ChangeType(_value, targetReturnType);
+				return true;
+			}
+			else if (targetReturnType == typeof(DynamicDictionary) && valueType == typeof(Dictionary<string, object>))
+			{
+				newObject = DynamicDictionary.Create(value as Dictionary<string, object>);
+				return true;
+			}
+
+			else if (targetReturnType == typeof(object))
+			{
+				newObject = value;
+				return true;
+			}
+		}
+		catch
+		{
 			return false;
 		}
+		return false;
+	}
 
 
 
-		public static bool operator ==(DynamicValue dynamicValue, object compareValue)
+	public static bool operator ==(DynamicValue dynamicValue, object compareValue)
+	{
+		if (dynamicValue._value == null && compareValue == null)
 		{
-			if (dynamicValue._value == null && compareValue == null)
-			{
-				return true;
-			}
-
-			return dynamicValue._value != null && dynamicValue._value.Equals(compareValue);
+			return true;
 		}
 
-		public static bool operator !=(DynamicValue dynamicValue, object compareValue) => !(dynamicValue == compareValue);
+		return dynamicValue._value != null && dynamicValue._value.Equals(compareValue);
+	}
+
+	public static bool operator !=(DynamicValue dynamicValue, object compareValue) => !(dynamicValue == compareValue);
 
-		/// <summary>
-		/// Determines whether the specified <see cref="object" /> is equal to the current <see cref="object" />.
-		/// </summary>
-		/// <returns>
-		/// <c>true</c> if the specified <see cref="object" /> is equal to the current <see cref="DynamicValue" />; otherwise,
-		/// <c>false</c>.
-		/// </returns>
-		/// <param name="compareValue">The <see cref="object" /> to compare with the current <see cref="DynamicValue" />.</param>
-		public override bool Equals(object compareValue)
+	/// <summary>
+	/// Determines whether the specified <see cref="object" /> is equal to the current <see cref="object" />.
+	/// </summary>
+	/// <returns>
+	/// <c>true</c> if the specified <see cref="object" /> is equal to the current <see cref="DynamicValue" />; otherwise,
+	/// <c>false</c>.
+	/// </returns>
+	/// <param name="compareValue">The <see cref="object" /> to compare with the current <see cref="DynamicValue" />.</param>
+	public override bool Equals(object compareValue)
+	{
+		if (ReferenceEquals(null, compareValue))
 		{
-			if (ReferenceEquals(null, compareValue))
-			{
-				return false;
-			}
+			return false;
+		}
 
-			if (ReferenceEquals(this, compareValue)
-				|| ReferenceEquals(_value, compareValue)
-				|| Equals(_value, compareValue)
-			)
-			{
-				return true;
-			}
+		if (ReferenceEquals(this, compareValue)
+			|| ReferenceEquals(_value, compareValue)
+			|| Equals(_value, compareValue)
+		)
+		{
+			return true;
+		}
+
+		return compareValue.GetType() == typeof(DynamicValue) && Equals((DynamicValue)compareValue);
+	}
 
-			return compareValue.GetType() == typeof(DynamicValue) && Equals((DynamicValue)compareValue);
+	/// <summary>
+	/// Serves as a hash function for a particular type.
+	/// </summary>
+	/// <returns>A hash code for the current instance.</returns>
+	public override int GetHashCode() => _value != null ? _value.GetHashCode() : 0;
+
+	/// <summary>
+	/// Provides implementation for binary operations. Classes derived from the <see cref="T:System.Dynamic.DynamicObject" /> class can override
+	/// this method to specify dynamic behavior for operations such as addition and multiplication.
+	/// </summary>
+	/// <returns>
+	/// <c>true</c> if the operation is successful; otherwise, <c>false</c>. If this method returns <c>false</c>, the run-time binder of
+	/// the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.)
+	/// </returns>
+	/// <param name="binder">
+	/// Provides information about the binary operation. The binder.Operation property returns an
+	/// <see cref="T:System.Linq.Expressions.ExpressionType" /> object. For example, for the sum = first + second statement, where first and second
+	/// are derived from the DynamicObject class, binder.Operation returns ExpressionType.Add.
+	/// </param>
+	/// <param name="arg">
+	/// The right operand for the binary operation. For example, for the sum = first + second statement, where first and second
+	/// are derived from the DynamicObject class, <paramref name="arg" /> is equal to second.
+	/// </param>
+	/// <param name="result">The result of the binary operation.</param>
+	public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
+	{
+		result = null;
+
+		if (binder.Operation != ExpressionType.Equal)
+		{
+			return false;
 		}
 
-		/// <summary>
-		/// Serves as a hash function for a particular type.
-		/// </summary>
-		/// <returns>A hash code for the current instance.</returns>
-		public override int GetHashCode() => _value != null ? _value.GetHashCode() : 0;
-
-		/// <summary>
-		/// Provides implementation for binary operations. Classes derived from the <see cref="T:System.Dynamic.DynamicObject" /> class can override
-		/// this method to specify dynamic behavior for operations such as addition and multiplication.
-		/// </summary>
-		/// <returns>
-		/// <c>true</c> if the operation is successful; otherwise, <c>false</c>. If this method returns <c>false</c>, the run-time binder of
-		/// the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.)
-		/// </returns>
-		/// <param name="binder">
-		/// Provides information about the binary operation. The binder.Operation property returns an
-		/// <see cref="T:System.Linq.Expressions.ExpressionType" /> object. For example, for the sum = first + second statement, where first and second
-		/// are derived from the DynamicObject class, binder.Operation returns ExpressionType.Add.
-		/// </param>
-		/// <param name="arg">
-		/// The right operand for the binary operation. For example, for the sum = first + second statement, where first and second
-		/// are derived from the DynamicObject class, <paramref name="arg" /> is equal to second.
-		/// </param>
-		/// <param name="result">The result of the binary operation.</param>
-		public override bool TryBinaryOperation(BinaryOperationBinder binder, object arg, out object result)
-		{
-			result = null;
-
-			if (binder.Operation != ExpressionType.Equal)
-			{
-				return false;
-			}
+		var convert =
+			Binder.Convert(CSharpBinderFlags.None, arg.GetType(), typeof(DynamicValue));
+
+		if (!TryConvert((ConvertBinder)convert, out var resultOfCast))
+		{
+			return false;
+		}
 
-			var convert =
-				Binder.Convert(CSharpBinderFlags.None, arg.GetType(), typeof(DynamicValue));
+		result = resultOfCast == null ? Equals(arg, resultOfCast) : resultOfCast.Equals(arg);
 
-			if (!TryConvert((ConvertBinder)convert, out var resultOfCast))
-			{
-				return false;
-			}
+		return true;
+	}
 
-			result = resultOfCast == null ? Equals(arg, resultOfCast) : resultOfCast.Equals(arg);
+	/// <summary>
+	/// Provides implementation for type conversion operations. Classes derived from the <see cref="T:System.Dynamic.DynamicObject" /> class can
+	/// override this method to specify dynamic behavior for operations that convert an object from one type to another.
+	/// </summary>
+	/// <returns>
+	/// <c>true</c> if the operation is successful; otherwise, <c>false</c>. If this method returns <c>false</c>, the run-time binder of
+	/// the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.)
+	/// </returns>
+	/// <param name="binder">
+	/// Provides information about the conversion operation. The binder.Type property provides the type to which the object
+	/// must be converted. For example, for the statement (String)sampleObject in C# (CType(sampleObject, Type) in Visual Basic), where
+	/// sampleObject is an instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject" /> class, binder.Type returns the
+	/// <see cref="T:System.String" /> type. The binder.Explicit property provides information about the kind of conversion that occurs. It returns
+	/// true for explicit conversion and false for implicit conversion.
+	/// </param>
+	/// <param name="result">The result of the type conversion operation.</param>
+	public override bool TryConvert(ConvertBinder binder, out object result)
+	{
+		result = null;
 
+		if (_value == null)
+		{
 			return true;
 		}
 
-		/// <summary>
-		/// Provides implementation for type conversion operations. Classes derived from the <see cref="T:System.Dynamic.DynamicObject" /> class can
-		/// override this method to specify dynamic behavior for operations that convert an object from one type to another.
-		/// </summary>
-		/// <returns>
-		/// <c>true</c> if the operation is successful; otherwise, <c>false</c>. If this method returns <c>false</c>, the run-time binder of
-		/// the language determines the behavior. (In most cases, a language-specific run-time exception is thrown.)
-		/// </returns>
-		/// <param name="binder">
-		/// Provides information about the conversion operation. The binder.Type property provides the type to which the object
-		/// must be converted. For example, for the statement (String)sampleObject in C# (CType(sampleObject, Type) in Visual Basic), where
-		/// sampleObject is an instance of the class derived from the <see cref="T:System.Dynamic.DynamicObject" /> class, binder.Type returns the
-		/// <see cref="T:System.String" /> type. The binder.Explicit property provides information about the kind of conversion that occurs. It returns
-		/// true for explicit conversion and false for implicit conversion.
-		/// </param>
-		/// <param name="result">The result of the type conversion operation.</param>
-		public override bool TryConvert(ConvertBinder binder, out object result)
-		{
-			result = null;
-
-			if (_value == null)
-			{
-				return true;
-			}
+		var binderType = binder.Type;
+
+		if (binderType == typeof(List<DynamicValue>))
+		{
+			result = ToEnumerable().ToList();
+			return true;
+		}
+		if (binderType == typeof(List<object>))
+		{
+			result = ToEnumerable().Cast<object>().ToList();
+			return true;
+		}
 
-			var binderType = binder.Type;
+		if (binderType == typeof(string))
+		{
+			result = Convert.ToString(_value);
+			return true;
+		}
 
-			if (binderType == typeof(List<DynamicValue>))
+		if (binderType == typeof(Guid) || binderType == typeof(Guid?))
+		{
+			if (Guid.TryParse(Convert.ToString(_value), out var guid))
 			{
-				result = ToEnumerable().ToList();
+				result = guid;
 				return true;
 			}
-			if (binderType == typeof(List<object>))
+		}
+		else if (binderType == typeof(TimeSpan) || binderType == typeof(TimeSpan?))
+		{
+			if (TimeSpan.TryParse(Convert.ToString(_value), out var timespan))
 			{
-				result = ToEnumerable().Cast<object>().ToList();
+				result = timespan;
 				return true;
 			}
+		}
+		else
+		{
+			if (binderType.IsGenericType && binderType.GetGenericTypeDefinition() == typeof(Nullable<>))
+				binderType = binderType.GetGenericArguments()[0];
 
-			if (binderType == typeof(string))
-			{
-				result = Convert.ToString(_value);
-				return true;
-			}
+			var typeCode = Type.GetTypeCode(binderType);
 
-			if (binderType == typeof(Guid) || binderType == typeof(Guid?))
-			{
-				if (Guid.TryParse(Convert.ToString(_value), out var guid))
-				{
-					result = guid;
-					return true;
-				}
-			}
-			else if (binderType == typeof(TimeSpan) || binderType == typeof(TimeSpan?))
+			if (typeCode == TypeCode.Object)
 			{
-				if (TimeSpan.TryParse(Convert.ToString(_value), out var timespan))
+				if (binderType.IsAssignableFrom(_value.GetType()))
 				{
-					result = timespan;
+					result = _value;
 					return true;
 				}
+				else
+					return false;
 			}
-			else
-			{
-				if (binderType.IsGenericType && binderType.GetGenericTypeDefinition() == typeof(Nullable<>))
-					binderType = binderType.GetGenericArguments()[0];
-
-				var typeCode = Type.GetTypeCode(binderType);
-
-				if (typeCode == TypeCode.Object)
-				{
-					if (binderType.IsAssignableFrom(_value.GetType()))
-					{
-						result = _value;
-						return true;
-					}
-					else
-						return false;
-				}
 
-				result = Convert.ChangeType(_value, typeCode);
-				return true;
-			}
-			return base.TryConvert(binder, out result);
+			result = Convert.ChangeType(_value, typeCode);
+			return true;
 		}
+		return base.TryConvert(binder, out result);
+	}
 
-		public override string ToString() => _value == null ? base.ToString() : Convert.ToString(_value);
-
-		public static implicit operator bool(DynamicValue dynamicValue)
-		{
-			if (!dynamicValue.HasValue) return false;
-			if (dynamicValue._value is JsonElement e) return e.GetBoolean();
+	public override string ToString() => _value == null ? base.ToString() : Convert.ToString(_value);
 
-			if (dynamicValue._value.GetType().IsValueType) return Convert.ToBoolean(dynamicValue._value);
+	public static implicit operator bool(DynamicValue dynamicValue)
+	{
+		if (!dynamicValue.HasValue) return false;
+		if (dynamicValue._value is JsonElement e) return e.GetBoolean();
 
-			if (bool.TryParse(dynamicValue.ToString(CultureInfo.InvariantCulture), out var result)) return result;
+		if (dynamicValue._value.GetType().IsValueType) return Convert.ToBoolean(dynamicValue._value);
 
-			return true;
-		}
+		if (bool.TryParse(dynamicValue.ToString(CultureInfo.InvariantCulture), out var result)) return result;
 
-		public static implicit operator string(DynamicValue dynamicValue)
-		{
-			if (!dynamicValue.HasValue) return null;
-			if (dynamicValue._value is JsonElement e) return e.GetString();
+		return true;
+	}
 
-			return Convert.ToString(dynamicValue._value);
-		}
+	public static implicit operator string(DynamicValue dynamicValue)
+	{
+		if (!dynamicValue.HasValue) return null;
+		if (dynamicValue._value is JsonElement e) return e.GetString();
 
-		public static implicit operator int(DynamicValue dynamicValue)
-		{
-			if (dynamicValue._value is JsonElement e && e.TryGetInt32(out var v)) return v;
-			if (dynamicValue._value.GetType().IsValueType) return Convert.ToInt32(dynamicValue._value);
+		return Convert.ToString(dynamicValue._value);
+	}
 
-			return int.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
-		}
+	public static implicit operator int(DynamicValue dynamicValue)
+	{
+		if (dynamicValue._value is JsonElement e && e.TryGetInt32(out var v)) return v;
+		if (dynamicValue._value.GetType().IsValueType) return Convert.ToInt32(dynamicValue._value);
 
-		public static implicit operator Guid(DynamicValue dynamicValue)
-		{
-			if (dynamicValue._value is JsonElement e && e.TryGetGuid(out var v)) return v;
-			return dynamicValue._value is Guid guid ? guid : Guid.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
-		}
+		return int.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
+	}
 
-		public static implicit operator DateTime(DynamicValue dynamicValue)
-		{
-			if (dynamicValue._value is JsonElement e && e.TryGetDateTime(out var v)) return v;
-			return dynamicValue._value is DateTime dateTime
-				? dateTime
-				: DateTime.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
-		}
+	public static implicit operator Guid(DynamicValue dynamicValue)
+	{
+		if (dynamicValue._value is JsonElement e && e.TryGetGuid(out var v)) return v;
+		return dynamicValue._value is Guid guid ? guid : Guid.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
+	}
 
-		public static implicit operator DateTimeOffset(DynamicValue dynamicValue)
-		{
-			if (dynamicValue._value is JsonElement e && e.TryGetDateTimeOffset(out var v)) return v;
-			return dynamicValue._value is DateTimeOffset offset ? offset : DateTimeOffset.Parse(dynamicValue);
-		}
+	public static implicit operator DateTime(DynamicValue dynamicValue)
+	{
+		if (dynamicValue._value is JsonElement e && e.TryGetDateTime(out var v)) return v;
+		return dynamicValue._value is DateTime dateTime
+			? dateTime
+			: DateTime.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
+	}
 
-		public static implicit operator TimeSpan(DynamicValue dynamicValue) =>
-			dynamicValue._value is TimeSpan timeSpan
-				? timeSpan
-				: TimeSpan.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
+	public static implicit operator DateTimeOffset(DynamicValue dynamicValue)
+	{
+		if (dynamicValue._value is JsonElement e && e.TryGetDateTimeOffset(out var v)) return v;
+		return dynamicValue._value is DateTimeOffset offset ? offset : DateTimeOffset.Parse(dynamicValue);
+	}
 
-		public static implicit operator long(DynamicValue dynamicValue)
-		{
-			if (dynamicValue._value is JsonElement e && e.TryGetInt64(out var v)) return v;
-			if (dynamicValue._value.GetType().IsValueType) return Convert.ToInt64(dynamicValue._value);
+	public static implicit operator TimeSpan(DynamicValue dynamicValue) =>
+		dynamicValue._value is TimeSpan timeSpan
+			? timeSpan
+			: TimeSpan.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
 
-			return long.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
-		}
+	public static implicit operator long(DynamicValue dynamicValue)
+	{
+		if (dynamicValue._value is JsonElement e && e.TryGetInt64(out var v)) return v;
+		if (dynamicValue._value.GetType().IsValueType) return Convert.ToInt64(dynamicValue._value);
 
-		public static implicit operator float(DynamicValue dynamicValue)
-		{
-			if (dynamicValue._value is JsonElement e && e.TryGetSingle(out var v)) return v;
-			if (dynamicValue._value.GetType().IsValueType) return Convert.ToSingle(dynamicValue._value);
+		return long.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
+	}
 
-			return float.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
-		}
+	public static implicit operator float(DynamicValue dynamicValue)
+	{
+		if (dynamicValue._value is JsonElement e && e.TryGetSingle(out var v)) return v;
+		if (dynamicValue._value.GetType().IsValueType) return Convert.ToSingle(dynamicValue._value);
 
-		public static implicit operator decimal(DynamicValue dynamicValue)
-		{
-			if (dynamicValue._value is JsonElement e && e.TryGetDecimal(out var v)) return v;
-			if (dynamicValue._value.GetType().IsValueType) return Convert.ToDecimal(dynamicValue._value);
+		return float.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
+	}
 
-			return decimal.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
-		}
+	public static implicit operator decimal(DynamicValue dynamicValue)
+	{
+		if (dynamicValue._value is JsonElement e && e.TryGetDecimal(out var v)) return v;
+		if (dynamicValue._value.GetType().IsValueType) return Convert.ToDecimal(dynamicValue._value);
 
-		public static implicit operator double(DynamicValue dynamicValue)
-		{
-			if (dynamicValue._value is JsonElement e && e.TryGetDouble(out var v)) return v;
-			if (dynamicValue._value.GetType().IsValueType) return Convert.ToDouble(dynamicValue._value);
+		return decimal.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
+	}
 
-			return double.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
-		}
+	public static implicit operator double(DynamicValue dynamicValue)
+	{
+		if (dynamicValue._value is JsonElement e && e.TryGetDouble(out var v)) return v;
+		if (dynamicValue._value.GetType().IsValueType) return Convert.ToDouble(dynamicValue._value);
 
-		public IEnumerable<DynamicValue> ToEnumerable()
-		{
-			using var e = GetEnumerator();
-			while(e.MoveNext())
-				yield return e.Current;
-		}
+		return double.Parse(dynamicValue.ToString(CultureInfo.InvariantCulture));
+	}
 
-		IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+	public IEnumerable<DynamicValue> ToEnumerable()
+	{
+		using var e = GetEnumerator();
+		while(e.MoveNext())
+			yield return e.Current;
+	}
 
-		public IEnumerator<DynamicValue> GetEnumerator()
-		{
-			if (Value is ICollection c) return c.OfType<object>().Select(v => SelfOrNew(v)).GetEnumerator();
-			else if (Value is IList l) return l.OfType<object>().Select(v => SelfOrNew(v)).GetEnumerator();
-			else if (Value is IDictionary<string, object> d) return d.Select(kv=> SelfOrNew(kv.Value)).GetEnumerator();
-			else if (Value is IDictionary<string, DynamicValue> dv) return dv.Values.GetEnumerator();
-			else if (Value is JsonElement e && e.ValueKind == JsonValueKind.Array) return e.EnumerateArray().Select(a=> SelfOrNew(a)).GetEnumerator();
-			else if (Value is JsonElement el && el.ValueKind == JsonValueKind.Object)
-				return ToDictionary().Values.Select(v => SelfOrNew(v)).GetEnumerator();
+	IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
-			return Value == null
-				? Enumerable.Empty<DynamicValue>().GetEnumerator()
-				: new List<DynamicValue>() { this }.GetEnumerator();
-		}
+	public IEnumerator<DynamicValue> GetEnumerator()
+	{
+		if (Value is ICollection c) return c.OfType<object>().Select(v => SelfOrNew(v)).GetEnumerator();
+		else if (Value is IList l) return l.OfType<object>().Select(v => SelfOrNew(v)).GetEnumerator();
+		else if (Value is IDictionary<string, object> d) return d.Select(kv=> SelfOrNew(kv.Value)).GetEnumerator();
+		else if (Value is IDictionary<string, DynamicValue> dv) return dv.Values.GetEnumerator();
+		else if (Value is JsonElement e && e.ValueKind == JsonValueKind.Array) return e.EnumerateArray().Select(a=> SelfOrNew(a)).GetEnumerator();
+		else if (Value is JsonElement el && el.ValueKind == JsonValueKind.Object)
+			return ToDictionary().Values.Select(v => SelfOrNew(v)).GetEnumerator();
+
+		return Value == null
+			? Enumerable.Empty<DynamicValue>().GetEnumerator()
+			: new List<DynamicValue>() { this }.GetEnumerator();
+	}
 
-		public int Count
+	public int Count
+	{
+		get
 		{
-			get
-			{
-				if (Value is ICollection c) return c.Count;
-				else if (Value is IList l) return l.Count;
-				else if (Value is IDictionary<string, object> d) return d.Count;
-				else if (Value is IDictionary<string, DynamicValue> dv) return dv.Count;
-				else if (Value is JsonElement e && e.ValueKind == JsonValueKind.Array) return e.GetArrayLength();
-				else if (Value is JsonElement el && el.ValueKind == JsonValueKind.Object) return el.EnumerateObject().Count();
-
-				return Value == null ? 0 : 1;
-			}
+			if (Value is ICollection c) return c.Count;
+			else if (Value is IList l) return l.Count;
+			else if (Value is IDictionary<string, object> d) return d.Count;
+			else if (Value is IDictionary<string, DynamicValue> dv) return dv.Count;
+			else if (Value is JsonElement e && e.ValueKind == JsonValueKind.Array) return e.GetArrayLength();
+			else if (Value is JsonElement el && el.ValueKind == JsonValueKind.Object) return el.EnumerateObject().Count();
+
+			return Value == null ? 0 : 1;
 		}
+	}
 
-		public DynamicValue this[int i]
+	public DynamicValue this[int i]
+	{
+		get
 		{
-			get
-			{
-				if (!HasValue) return NullValue;
-
-				var v = Value;
+			if (!HasValue) return NullValue;
 
-				if (v is IList l && l.Count - 1 >= i)
-					return SelfOrNew(l[i]);
-				if (v is IList<object> o && o.Count - 1 >= i)
-					return SelfOrNew(o[i]);
+			var v = Value;
 
-				if (v is IDictionary<string, object> d)
-				{
-					if (d.TryGetValue(i.ToString(CultureInfo.InvariantCulture), out v))
-						return SelfOrNew(v);
+			if (v is IList l && l.Count - 1 >= i)
+				return SelfOrNew(l[i]);
+			if (v is IList<object> o && o.Count - 1 >= i)
+				return SelfOrNew(o[i]);
 
-					if (i >= d.Count) return new DynamicValue(null);
-					var at = d[d.Keys.ElementAt(i)];
-					return SelfOrNew(at);
-				}
-				if (v is IDictionary<string, DynamicValue> dv)
-				{
-					if (dv.TryGetValue(i.ToString(CultureInfo.InvariantCulture), out var dvv))
-						return dvv;
+			if (v is IDictionary<string, object> d)
+			{
+				if (d.TryGetValue(i.ToString(CultureInfo.InvariantCulture), out v))
+					return SelfOrNew(v);
 
-					if (i >= dv.Count) return new DynamicValue(null);
-					var at = dv[dv.Keys.ElementAt(i)];
-					return at;
-				}
-				if (v is JsonElement e && e.ValueKind == JsonValueKind.Array)
-				{
-					if (e.GetArrayLength() -1 >= i)
-						return SelfOrNew(e[i]);
-				}
-				if (v is JsonElement el && el.ValueKind == JsonValueKind.Object)
-				{
-					return SelfOrNew(el.GetProperty(i.ToString(CultureInfo.InvariantCulture)));
-				}
+				if (i >= d.Count) return new DynamicValue(null);
+				var at = d[d.Keys.ElementAt(i)];
+				return SelfOrNew(at);
+			}
+			if (v is IDictionary<string, DynamicValue> dv)
+			{
+				if (dv.TryGetValue(i.ToString(CultureInfo.InvariantCulture), out var dvv))
+					return dvv;
 
-				return NullValue;
+				if (i >= dv.Count) return new DynamicValue(null);
+				var at = dv[dv.Keys.ElementAt(i)];
+				return at;
+			}
+			if (v is JsonElement e && e.ValueKind == JsonValueKind.Array)
+			{
+				if (e.GetArrayLength() -1 >= i)
+					return SelfOrNew(e[i]);
+			}
+			if (v is JsonElement el && el.ValueKind == JsonValueKind.Object)
+			{
+				return SelfOrNew(el.GetProperty(i.ToString(CultureInfo.InvariantCulture)));
 			}
+
+			return NullValue;
 		}
+	}
 
 
 
 
-	}
 }
diff --git a/src/Elastic.Transport/Responses/EmptyError.cs b/src/Elastic.Transport/Responses/EmptyError.cs
new file mode 100644
index 0000000..5fad61b
--- /dev/null
+++ b/src/Elastic.Transport/Responses/EmptyError.cs
@@ -0,0 +1,16 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+namespace Elastic.Transport;
+
+/// <summary>
+/// 
+/// </summary>
+internal sealed class EmptyError : ErrorResponse
+{
+	public static readonly EmptyError Instance = new();
+
+	/// <inheritdoc cref="ErrorResponse.HasError" />
+	public override bool HasError() => false;
+}
diff --git a/src/Elastic.Transport/Responses/IErrorResponse.cs b/src/Elastic.Transport/Responses/ErrorResponse.cs
similarity index 76%
rename from src/Elastic.Transport/Responses/IErrorResponse.cs
rename to src/Elastic.Transport/Responses/ErrorResponse.cs
index d0b3174..a0af300 100644
--- a/src/Elastic.Transport/Responses/IErrorResponse.cs
+++ b/src/Elastic.Transport/Responses/ErrorResponse.cs
@@ -9,20 +9,11 @@ namespace Elastic.Transport;
 /// </summary>
 public abstract class ErrorResponse
 {
+	internal ErrorResponse() { }
+
 	/// <summary>
 	/// May be called by transport to establish whether the instance represents a valid, complete error.
 	/// <para>This may not always be the case if the error is partially deserialised on the response.</para>
 	/// </summary>
 	public abstract bool HasError();
 }
-
-/// <summary>
-/// 
-/// </summary>
-internal sealed class EmptyError : ErrorResponse
-{
-	public static readonly EmptyError Instance = new();
-
-	/// <inheritdoc cref="ErrorResponse.HasError" />
-	public override bool HasError() => false;
-}
diff --git a/src/Elastic.Transport/Responses/HttpDetails/ApiCallDetails.cs b/src/Elastic.Transport/Responses/HttpDetails/ApiCallDetails.cs
index 0f543d0..09d7394 100644
--- a/src/Elastic.Transport/Responses/HttpDetails/ApiCallDetails.cs
+++ b/src/Elastic.Transport/Responses/HttpDetails/ApiCallDetails.cs
@@ -10,85 +10,129 @@
 using Elastic.Transport.Diagnostics.Auditing;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// 
+/// </summary>
+public sealed class ApiCallDetails
 {
-	/// <inheritdoc cref="IApiCallDetails"/>
-	public sealed class ApiCallDetails : IApiCallDetails
-	{
-		private string _debugInformation;
+	private string _debugInformation;
 
-		/// <inheritdoc cref="IApiCallDetails.AuditTrail"/>
-		public IEnumerable<Audit> AuditTrail { get; set; }
+	internal ApiCallDetails() { }
 
-		/// <inheritdoc cref="IApiCallDetails.ThreadPoolStats"/>
-		public IReadOnlyDictionary<string, ThreadPoolStatistics> ThreadPoolStats { get; set; }
+	/// <summary>
+	/// 
+	/// </summary>>
+	public IEnumerable<Audit> AuditTrail { get; internal set; }
 
-		/// <inheritdoc cref="IApiCallDetails.TcpStats"/>
-		public IReadOnlyDictionary<TcpState, int> TcpStats { get; set; }
+	/// <summary>
+	/// 
+	/// </summary>
+	internal IReadOnlyDictionary<string, ThreadPoolStatistics> ThreadPoolStats { get; set; }
 
-		/// <inheritdoc cref="IApiCallDetails.DebugInformation"/>
-		public string DebugInformation
-		{
-			get
-			{
-				if (_debugInformation != null)
-					return _debugInformation;
-
-				var sb = new StringBuilder();
-				sb.AppendLine(ToString());
-				_debugInformation = ResponseStatics.DebugInformationBuilder(this, sb);
+	/// <summary>
+	/// 
+	/// </summary>
+	internal IReadOnlyDictionary<TcpState, int> TcpStats { get; set; }
 
+	/// <summary>
+	/// 
+	/// </summary>
+	public string DebugInformation
+	{
+		get
+		{
+			if (_debugInformation != null)
 				return _debugInformation;
-			}
-		}
-
-		/// <inheritdoc cref="IApiCallDetails.HttpMethod"/>
-		public HttpMethod HttpMethod { get; set; }
-
-		/// <inheritdoc cref="IApiCallDetails.HttpStatusCode"/>
-		public int? HttpStatusCode { get; set; }
-
-		/// <inheritdoc cref="IApiCallDetails.OriginalException"/>
-		public Exception OriginalException { get; set; }
 
-		/// <inheritdoc cref="IApiCallDetails.RequestBodyInBytes"/>
-		public byte[] RequestBodyInBytes { get; set; }
+			var sb = new StringBuilder();
+			sb.AppendLine(ToString());
+			_debugInformation = ResponseStatics.DebugInformationBuilder(this, sb);
 
-		/// <inheritdoc cref="IApiCallDetails.RequestBodyInBytes"/>
-		public byte[] ResponseBodyInBytes { get; set; }
-
-		/// <inheritdoc cref="IApiCallDetails.ResponseMimeType"/>
-		public string ResponseMimeType { get; set; }
-
-		/// <inheritdoc cref="IApiCallDetails.Success"/>
-		public bool Success { get; set; }
-
-		/// <inheritdoc cref="IApiCallDetails.SuccessOrKnownError"/>
-		public bool SuccessOrKnownError =>
-			Success || HttpStatusCode >= 400
-			&& HttpStatusCode < 599
-			&& HttpStatusCode != 504 //Gateway timeout needs to be retried
-			&& HttpStatusCode != 503 //service unavailable needs to be retried
-			&& HttpStatusCode != 502;
-
-		/// <inheritdoc cref="IApiCallDetails.Uri"/>
-		public Uri Uri { get; set; }
-
-		/// <inheritdoc cref="IApiCallDetails.TransportConfiguration"/>
-		public ITransportConfiguration TransportConfiguration { get; set; }
-
-		/// <inheritdoc cref="IApiCallDetails.ParsedHeaders"/>
-		public IReadOnlyDictionary<string, IEnumerable<string>> ParsedHeaders { get; set; }
-
-		/// <summary>
-		/// The error response is the server returned JSON describing a server error.
-		/// </summary>
-		public ErrorResponse ErrorResponse { get; set; } = EmptyError.Instance;
-
-		/// <summary>
-		/// A string summarising the API call.
-		/// </summary>
-		public override string ToString() =>
-			$"{(Success ? "S" : "Uns")}uccessful ({HttpStatusCode}) low level call on {HttpMethod.GetStringValue()}: {Uri.PathAndQuery}";
+			return _debugInformation;
+		}
 	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public HttpMethod HttpMethod { get; internal set; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public int? HttpStatusCode { get; internal set; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public Exception OriginalException { get; internal set; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public byte[] RequestBodyInBytes { get; internal set; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public byte[] ResponseBodyInBytes { get; internal set; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	internal string ResponseMimeType { get; set; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public bool Success { get; internal set; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	internal bool SuccessOrKnownError =>
+		Success || HttpStatusCode >= 400
+		&& HttpStatusCode < 599
+		&& HttpStatusCode != 504 //Gateway timeout needs to be retried
+		&& HttpStatusCode != 503 //service unavailable needs to be retried
+		&& HttpStatusCode != 502;
+
+	/// <summary>
+	/// 
+	/// </summary>
+	public Uri Uri { get; internal set; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	internal ITransportConfiguration TransportConfiguration { get; set; }
+
+	/// <summary>
+	/// 
+	/// </summary>
+	internal IReadOnlyDictionary<string, IEnumerable<string>> ParsedHeaders { get; set; }
+		= EmptyReadOnly<string, IEnumerable<string>>.Dictionary;
+
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <param name="key"></param>
+	/// <param name="headerValues"></param>
+	/// <returns></returns>
+	// TODO: Nullable annotations
+	public bool TryGetHeader(string key, out IEnumerable<string> headerValues) =>
+		ParsedHeaders.TryGetValue(key, out headerValues);
+
+	/// <summary>
+	/// The error response if the server returned JSON describing a server error.
+	/// </summary>
+	internal ErrorResponse ErrorResponse { get; set; } = EmptyError.Instance;
+
+	/// <summary>
+	/// A string summarising the API call.
+	/// </summary>
+	public override string ToString() =>
+		$"{(Success ? "S" : "Uns")}uccessful ({HttpStatusCode}) low level call on {HttpMethod.GetStringValue()}: {(Uri is not null ? Uri.PathAndQuery: "UNKNOWN URI")}";
 }
diff --git a/src/Elastic.Transport/Responses/HttpDetails/IApiCallDetails.cs b/src/Elastic.Transport/Responses/HttpDetails/IApiCallDetails.cs
deleted file mode 100644
index cd2b405..0000000
--- a/src/Elastic.Transport/Responses/HttpDetails/IApiCallDetails.cs
+++ /dev/null
@@ -1,96 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Net.NetworkInformation;
-using Elastic.Transport.Diagnostics;
-using Elastic.Transport.Diagnostics.Auditing;
-
-namespace Elastic.Transport
-{
-	/// <summary> Details about the API call.</summary>
-	public interface IApiCallDetails
-	{
-        /// <summary>
-        /// An audit trail of requests made to nodes within the cluster.
-        /// </summary>
-        IEnumerable<Audit> AuditTrail { get; }
-
-		/// <summary>
-		/// Thread pool thread statistics collected when making a request.
-		/// </summary>
-		IReadOnlyDictionary<string, ThreadPoolStatistics> ThreadPoolStats { get; }
-
-		/// <summary>
-		/// Active TCP connection statistics collected when making a request.
-		/// </summary>
-		IReadOnlyDictionary<TcpState, int> TcpStats { get; }
-
-		/// <summary>
-        /// A human readable string representation of what happened during this request for both successful and failed requests.
-        /// </summary>
-        string DebugInformation { get; }
-
-		/// <summary>
-		/// Reference to the connection configuration that yielded this response.
-		/// </summary>
-		ITransportConfiguration TransportConfiguration { get; }
-
-		/// <summary>
-		/// The HTTP method used by the request.
-		/// </summary>
-		HttpMethod HttpMethod { get; }
-
-		/// <summary> The HTTP status code of the response.</summary>
-		int? HttpStatusCode { get; }
-
-		/// <summary>
-		/// If <see cref="Success"/> is <c>false</c>, this will hold the original exception.
-		/// This will be the originating CLR exception in most cases.
-		/// </summary>
-		Exception OriginalException { get; }
-
-		/// <summary>
-		/// A dictionary of the headers parsed from the HTTP response.
-		/// When no headers have been configured for parsing, or no matching headers were found,
-		/// this will be null.
-		/// </summary>
-		IReadOnlyDictionary<string, IEnumerable<string>> ParsedHeaders { get; }
-
-		/// <summary>
-		/// The request body bytes.
-		/// <para>NOTE: Only set when disable direct streaming is set for the request.</para>
-		/// </summary>
-		[DebuggerDisplay("{RequestBodyInBytes != null ? System.Text.Encoding.UTF8.GetString(RequestBodyInBytes) : null,nq}")]
-		byte[] RequestBodyInBytes { get; }
-
-        /// <summary>
-        /// The response body bytes.
-        /// <para>NOTE: Only set when disable direct streaming is set for the request.</para>
-        /// </summary>
-        [DebuggerDisplay("{ResponseBodyInBytes != null ? System.Text.Encoding.UTF8.GetString(ResponseBodyInBytes) : null,nq}")]
-		byte[] ResponseBodyInBytes { get; }
-
-		/// <summary>The MIME type of the response.</summary>
-		string ResponseMimeType { get; }
-
-		/// <summary>
-		/// The response status code is in the 200 range or is in the allowed list of status codes set on the request.
-		/// </summary>
-		bool Success { get; }
-
-		/// <summary>
-		/// The response is successful or has a response code between 400-599, the call should not be retried.
-		/// Only for 502, 503 and 504 will this return false;
-		/// </summary>
-		bool SuccessOrKnownError { get; }
-
-		/// <summary>
-		/// The <see cref="Uri"/> from the request.
-		/// </summary>
-		Uri Uri { get; }
-	}
-}
diff --git a/src/Elastic.Transport/Responses/ITransportResponse.cs b/src/Elastic.Transport/Responses/ITransportResponse.cs
deleted file mode 100644
index 8eec3d4..0000000
--- a/src/Elastic.Transport/Responses/ITransportResponse.cs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-namespace Elastic.Transport
-{
-	/// <summary>
-	/// The minimum interface which custom responses should implement.
-	/// </summary>
-	public interface ITransportResponse
-	{
-		/// <summary>
-		/// <see cref="ITransport{TConnectionSettings}"/> sets the <see cref="IApiCallDetails" /> diagnostic information about the request and response.
-		/// </summary>
-		IApiCallDetails ApiCall { get; set; }
-	}
-}
diff --git a/src/Elastic.Transport/Responses/ResponseFactory.cs b/src/Elastic.Transport/Responses/ResponseFactory.cs
new file mode 100644
index 0000000..20d6909
--- /dev/null
+++ b/src/Elastic.Transport/Responses/ResponseFactory.cs
@@ -0,0 +1,58 @@
+// Licensed to Elasticsearch B.V under one or more agreements.
+// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
+// See the LICENSE file in the project root for more information
+
+namespace Elastic.Transport;
+
+/// <summary>
+/// TODO
+/// </summary>
+public static class ResponseFactory
+{
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <returns></returns>
+	public static T CreateResponse<T>(T response, int statusCode) where T : TransportResponse =>
+		CreateResponse<T>(response, statusCode, true);
+
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="response"></param>
+	/// <param name="statusCode"></param>
+	/// <param name="success"></param>
+	/// <returns></returns>
+	public static T CreateResponse<T>(T response, int statusCode, bool success) where T : TransportResponse =>
+		CreateResponse<T>(response, statusCode, HttpMethod.GET, success);
+
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="response"></param>
+	/// <param name="statusCode"></param>
+	/// <param name="httpMethod"></param>
+	/// <param name="success"></param>
+	/// <returns></returns>
+	public static T CreateResponse<T>(T response, int statusCode, HttpMethod httpMethod, bool success) where T : TransportResponse
+	{
+		var apiCallDetails = new ApiCallDetails { HttpStatusCode = statusCode, Success = success, HttpMethod = httpMethod };
+		return CreateResponse<T>(response, apiCallDetails);
+	}
+
+	/// <summary>
+	/// 
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	/// <param name="response"></param>
+	/// <param name="apiCallDetails"></param>
+	/// <returns></returns>
+	internal static T CreateResponse<T>(T response, ApiCallDetails apiCallDetails) where T : TransportResponse
+	{
+		response.ApiCallDetails = apiCallDetails;
+		return response;
+	}
+}
diff --git a/src/Elastic.Transport/Responses/ResponseStatics.cs b/src/Elastic.Transport/Responses/ResponseStatics.cs
index 8abbe95..51f199f 100644
--- a/src/Elastic.Transport/Responses/ResponseStatics.cs
+++ b/src/Elastic.Transport/Responses/ResponseStatics.cs
@@ -9,120 +9,118 @@
 using Elastic.Transport.Diagnostics.Auditing;
 using Elastic.Transport.Extensions;
 
-namespace Elastic.Transport
+namespace Elastic.Transport.Diagnostics;
+
+/// <summary>
+/// Creates human readable debug strings based on <see cref="ApiCallDetails"/> so that
+/// its clear what exactly transpired during a call into <see cref="HttpTransport.Request{TResponse}"/>
+/// </summary>
+internal static class ResponseStatics
 {
-	//TODO Put in diagnostics folder/namespace
-	/// <summary>
-	/// Creates human readable debug strings based on <see cref="IApiCallDetails"/> so that
-	/// its clear what exactly transpired during a call into <see cref="ITransport.Request{TResponse}"/>
-	/// </summary>
-	internal static class ResponseStatics
-	{
-		private static readonly string RequestAlreadyCaptured =
-			"<Request stream not captured or already read to completion by serializer. Set DisableDirectStreaming() on ConnectionSettings to force it to be set on the response.>";
+	private static readonly string RequestAlreadyCaptured =
+		"<Request stream not captured or already read to completion by serializer. Set DisableDirectStreaming() on ConnectionSettings to force it to be set on the response.>";
 
-		private static readonly string ResponseAlreadyCaptured =
-			"<Response stream not captured or already read to completion by serializer. Set DisableDirectStreaming() on ConnectionSettings to force it to be set on the response.>";
+	private static readonly string ResponseAlreadyCaptured =
+		"<Response stream not captured or already read to completion by serializer. Set DisableDirectStreaming() on ConnectionSettings to force it to be set on the response.>";
 
-		/// <inheritdoc cref="ResponseStatics"/>
-		public static string DebugInformationBuilder(IApiCallDetails r, StringBuilder sb)
+	/// <inheritdoc cref="ResponseStatics"/>
+	public static string DebugInformationBuilder(ApiCallDetails r, StringBuilder sb)
+	{
+		sb.AppendLine($"# Audit trail of this API call:");
+		var auditTrail = (r.AuditTrail ?? Enumerable.Empty<Audit>()).ToList();
+		DebugAuditTrail(auditTrail, sb);
+		if (r.OriginalException != null) sb.AppendLine($"# OriginalException: {r.OriginalException}");
+		DebugAuditTrailExceptions(auditTrail, sb);
+
+		var response = r.ResponseBodyInBytes?.Utf8String() ?? ResponseAlreadyCaptured;
+		var request = r.RequestBodyInBytes?.Utf8String() ?? RequestAlreadyCaptured;
+		sb.AppendLine($"# Request:{Environment.NewLine}{request}");
+		sb.AppendLine($"# Response:{Environment.NewLine}{response}");
+
+		if (r.TcpStats != null)
 		{
-			sb.AppendLine($"# Audit trail of this API call:");
-			var auditTrail = (r.AuditTrail ?? Enumerable.Empty<Audit>()).ToList();
-			DebugAuditTrail(auditTrail, sb);
-			if (r.OriginalException != null) sb.AppendLine($"# OriginalException: {r.OriginalException}");
-			DebugAuditTrailExceptions(auditTrail, sb);
-
-			var response = r.ResponseBodyInBytes?.Utf8String() ?? ResponseAlreadyCaptured;
-			var request = r.RequestBodyInBytes?.Utf8String() ?? RequestAlreadyCaptured;
-			sb.AppendLine($"# Request:{Environment.NewLine}{request}");
-			sb.AppendLine($"# Response:{Environment.NewLine}{response}");
-
-			if (r.TcpStats != null)
+			sb.AppendLine("# TCP states:");
+			foreach (var stat in r.TcpStats)
 			{
-				sb.AppendLine("# TCP states:");
-				foreach (var stat in r.TcpStats)
-				{
-					sb.Append("  ");
-					sb.Append(stat.Key);
-					sb.Append(": ");
-					sb.AppendLine($"{stat.Value}");
-				}
-				sb.AppendLine();
+				sb.Append("  ");
+				sb.Append(stat.Key);
+				sb.Append(": ");
+				sb.AppendLine($"{stat.Value}");
 			}
+			sb.AppendLine();
+		}
 
-			if (r.ThreadPoolStats != null)
+		if (r.ThreadPoolStats != null)
+		{
+			sb.AppendLine("# ThreadPool statistics:");
+			foreach (var stat in r.ThreadPoolStats)
 			{
-				sb.AppendLine("# ThreadPool statistics:");
-				foreach (var stat in r.ThreadPoolStats)
-				{
-					sb.Append("  ");
-					sb.Append(stat.Key);
-					sb.AppendLine(": ");
-					sb.Append("    Busy: ");
-					sb.AppendLine($"{stat.Value.Busy}");
-					sb.Append("    Free: ");
-					sb.AppendLine($"{stat.Value.Free}");
-					sb.Append("    Min: ");
-					sb.AppendLine($"{stat.Value.Min}");
-					sb.Append("    Max: ");
-					sb.AppendLine($"{stat.Value.Max}");
-				}
-				sb.AppendLine();
+				sb.Append("  ");
+				sb.Append(stat.Key);
+				sb.AppendLine(": ");
+				sb.Append("    Busy: ");
+				sb.AppendLine($"{stat.Value.Busy}");
+				sb.Append("    Free: ");
+				sb.AppendLine($"{stat.Value.Free}");
+				sb.Append("    Min: ");
+				sb.AppendLine($"{stat.Value.Min}");
+				sb.Append("    Max: ");
+				sb.AppendLine($"{stat.Value.Max}");
 			}
-
-			return sb.ToString();
+			sb.AppendLine();
 		}
 
-		/// <summary>
-		/// Write the exceptions recorded in <paramref name="auditTrail"/> to <paramref name="sb"/> in
-		/// a debuggable and human readable string
-		/// </summary>
-		public static void DebugAuditTrailExceptions(IEnumerable<Audit> auditTrail, StringBuilder sb)
-		{
-			if (auditTrail == null) return;
+		return sb.ToString();
+	}
 
-			var auditExceptions = auditTrail.Select((audit, i) => new { audit, i }).Where(a => a.audit.Exception != null);
-			foreach (var a in auditExceptions)
-				sb.AppendLine($"# Audit exception in step {a.i + 1} {a.audit.Event.GetStringValue()}:{Environment.NewLine}{a.audit.Exception}");
-		}
+	/// <summary>
+	/// Write the exceptions recorded in <paramref name="auditTrail"/> to <paramref name="sb"/> in
+	/// a debuggable and human readable string
+	/// </summary>
+	public static void DebugAuditTrailExceptions(IEnumerable<Audit> auditTrail, StringBuilder sb)
+	{
+		if (auditTrail == null) return;
 
-		/// <summary>
-		/// Write the events recorded in <paramref name="auditTrail"/> to <paramref name="sb"/> in
-		/// a debuggable and human readable string
-		/// </summary>
-		public static void DebugAuditTrail(IEnumerable<Audit> auditTrail, StringBuilder sb)
-		{
-			if (auditTrail == null) return;
+		var auditExceptions = auditTrail.Select((audit, i) => new { audit, i }).Where(a => a.audit.Exception != null);
+		foreach (var a in auditExceptions)
+			sb.AppendLine($"# Audit exception in step {a.i + 1} {a.audit.Event.GetStringValue()}:{Environment.NewLine}{a.audit.Exception}");
+	}
 
-			foreach (var a in auditTrail.Select((a, i) => new { a, i }))
-			{
-				var audit = a.a;
-				sb.Append($" - [{a.i + 1}] {audit.Event.GetStringValue()}:");
+	/// <summary>
+	/// Write the events recorded in <paramref name="auditTrail"/> to <paramref name="sb"/> in
+	/// a debuggable and human readable string
+	/// </summary>
+	public static void DebugAuditTrail(IEnumerable<Audit> auditTrail, StringBuilder sb)
+	{
+		if (auditTrail == null) return;
 
-				AuditNodeUrl(sb, audit);
+		foreach (var a in auditTrail.Select((a, i) => new { a, i }))
+		{
+			var audit = a.a;
+			sb.Append($" - [{a.i + 1}] {audit.Event.GetStringValue()}:");
 
-				if (audit.Exception != null) sb.Append($" Exception: {audit.Exception.GetType().Name}");
-				if (audit.Ended == default)
-					sb.AppendLine();
-				else sb.AppendLine($" Took: {(audit.Ended - audit.Started).ToString()}");
-			}
+			AuditNodeUrl(sb, audit);
+
+			if (audit.Exception != null) sb.Append($" Exception: {audit.Exception.GetType().Name}");
+			if (audit.Ended == default)
+				sb.AppendLine();
+			else sb.AppendLine($" Took: {(audit.Ended - audit.Started).ToString()}");
 		}
+	}
 
-		private static void AuditNodeUrl(StringBuilder sb, Audit audit)
-		{
-			var uri = audit.Node?.Uri;
-			if (uri == null) return;
+	private static void AuditNodeUrl(StringBuilder sb, Audit audit)
+	{
+		var uri = audit.Node?.Uri;
+		if (uri == null) return;
 
-			if (!string.IsNullOrEmpty(uri.UserInfo))
+		if (!string.IsNullOrEmpty(uri.UserInfo))
+		{
+			var builder = new UriBuilder(uri)
 			{
-				var builder = new UriBuilder(uri)
-				{
-					Password = "redacted"
-				};
-				uri = builder.Uri;
-			}
-			sb.Append($" Node: {uri}");
+				Password = "redacted"
+			};
+			uri = builder.Uri;
 		}
+		sb.Append($" Node: {uri}");
 	}
 }
diff --git a/src/Elastic.Transport/Responses/Special/BytesResponse.cs b/src/Elastic.Transport/Responses/Special/BytesResponse.cs
index 77ec886..a4a3157 100644
--- a/src/Elastic.Transport/Responses/Special/BytesResponse.cs
+++ b/src/Elastic.Transport/Responses/Special/BytesResponse.cs
@@ -4,17 +4,16 @@
 
 using System;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A response that exposes the response <see cref="TransportResponse{T}.Body"/> as byte array
+/// </summary>
+public sealed class BytesResponse : TransportResponse<byte[]>
 {
-	/// <summary>
-	/// A response that exposes the response <see cref="TransportResponse{T}.Body"/> as byte array
-	/// </summary>
-	public sealed class BytesResponse : TransportResponse<byte[]>
-	{
-		/// <inheritdoc cref="BytesResponse"/>
-		public BytesResponse() => Body = Array.Empty<byte>();
+	/// <inheritdoc cref="BytesResponse"/>
+	public BytesResponse() => Body = Array.Empty<byte>();
 
-		/// <inheritdoc cref="BytesResponse"/>
-		public BytesResponse(byte[] body) => Body = body;
-	}
+	/// <inheritdoc cref="BytesResponse"/>
+	public BytesResponse(byte[] body) => Body = body;
 }
diff --git a/src/Elastic.Transport/Responses/Special/StringResponse.cs b/src/Elastic.Transport/Responses/Special/StringResponse.cs
index b604b08..879fa5b 100644
--- a/src/Elastic.Transport/Responses/Special/StringResponse.cs
+++ b/src/Elastic.Transport/Responses/Special/StringResponse.cs
@@ -2,17 +2,16 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A response that exposes the response <see cref="TransportResponse{T}.Body"/> as <see cref="string"/>.
+/// </summary>
+public sealed class StringResponse : TransportResponse<string>
 {
-	/// <summary>
-	/// A response that exposes the response <see cref="TransportResponse{T}.Body"/> as <see cref="string"/>.
-	/// </summary>
-	public sealed class StringResponse : TransportResponse<string>
-	{
-		/// <inheritdoc cref="StringResponse"/>
-		public StringResponse() => Body = string.Empty;
+	/// <inheritdoc cref="StringResponse"/>
+	public StringResponse() => Body = string.Empty;
 
-		/// <inheritdoc cref="StringResponse"/>
-		public StringResponse(string body) => Body = body;
-	}
+	/// <inheritdoc cref="StringResponse"/>
+	public StringResponse(string body) => Body = body;
 }
diff --git a/src/Elastic.Transport/Responses/Special/VoidResponse.cs b/src/Elastic.Transport/Responses/Special/VoidResponse.cs
index 2dc1e70..58f4c9d 100644
--- a/src/Elastic.Transport/Responses/Special/VoidResponse.cs
+++ b/src/Elastic.Transport/Responses/Special/VoidResponse.cs
@@ -2,24 +2,23 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A special response that omits reading the response from the server after reading the headers.
+/// </summary>
+public sealed class VoidResponse : TransportResponse<VoidResponse.VoidBody>
 {
+	/// <inheritdoc cref="VoidResponse"/>
+	public VoidResponse() => Body = new VoidBody();
+
 	/// <summary>
-	/// A special response that omits reading the response from the server after reading the headers.
+	/// A static <see cref="VoidResponse"/> instance that can be reused.
 	/// </summary>
-	public sealed class VoidResponse : TransportResponse<VoidResponse.VoidBody>
-	{
-		/// <inheritdoc cref="VoidResponse"/>
-		public VoidResponse() => Body = new VoidBody();
-
-		/// <summary>
-		/// A static <see cref="VoidResponse"/> instance that can be reused.
-		/// </summary>
-		public static VoidResponse Default { get; } = new VoidResponse();
+	public static VoidResponse Default { get; } = new VoidResponse();
 
-		/// <summary>
-		/// A class that represents the absence of having read the servers response to completion.
-		/// </summary>
-		public class VoidBody { }
-	}
+	/// <summary>
+	/// A class that represents the absence of having read the servers response to completion.
+	/// </summary>
+	public class VoidBody { }
 }
diff --git a/src/Elastic.Transport/Responses/TransportResponse.cs b/src/Elastic.Transport/Responses/TransportResponse.cs
index 46f0aca..79c230b 100644
--- a/src/Elastic.Transport/Responses/TransportResponse.cs
+++ b/src/Elastic.Transport/Responses/TransportResponse.cs
@@ -2,94 +2,30 @@
 // Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information
 
-using System;
-using System.Collections.Generic;
-using System.Net.NetworkInformation;
 using System.Text.Json.Serialization;
-using Elastic.Transport.Diagnostics;
-using Elastic.Transport.Diagnostics.Auditing;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+/// A response from an Elastic product including details about the request/response life cycle. Base class for the built in low level response
+/// types, <see cref="StringResponse"/>, <see cref="BytesResponse"/>, <see cref="DynamicResponse"/> and <see cref="VoidResponse"/>
+/// </summary>
+public abstract class TransportResponse<T> : TransportResponse
 {
 	/// <summary>
-	/// A response from an Elastic product including details about the request/response life cycle. Base class for the built in low level response
-	/// types, <see cref="StringResponse"/>, <see cref="BytesResponse"/>, <see cref="DynamicResponse"/> and <see cref="VoidResponse"/>
+	/// The deserialized body returned by the product.
 	/// </summary>
-	public abstract class TransportResponse<T> : TransportResponse
-	{
-		/// <summary>
-		/// The deserialized body returned by the product.
-		/// </summary>
-		public T Body { get; protected internal set; }
-	}
+	public T Body { get; protected internal set; }
+}
 
+/// <summary>
+/// A response as returned by <see cref="HttpTransport{TConnectionSettings}"/> including details about the request/response life cycle.
+/// </summary>
+public abstract class TransportResponse
+{
 	/// <summary>
-	/// A response as returned by <see cref="ITransport{TConnectionSettings}"/> including details about the request/response life cycle.
+	/// 
 	/// </summary>
-	public abstract class TransportResponse : IApiCallDetails, ITransportResponse
-	{
-		/// <inheritdoc />
-		[JsonIgnore]
-		public IApiCallDetails ApiCall { get; set; }
-
-		/// <inheritdoc cref="IApiCallDetails.TcpStats"/>
-		[JsonIgnore]
-		public IReadOnlyDictionary<TcpState, int> TcpStats => ApiCall.TcpStats;
-
-		/// <inheritdoc cref="IApiCallDetails.DebugInformation"/>
-		[JsonIgnore]
-		public string DebugInformation => ApiCall.DebugInformation;
-
-		/// <inheritdoc cref="IApiCallDetails.HttpMethod"/>
-		[JsonIgnore]
-		public HttpMethod HttpMethod => ApiCall.HttpMethod;
-
-		/// <inheritdoc cref="IApiCallDetails.AuditTrail"/>
-		[JsonIgnore]
-		public IEnumerable<Audit> AuditTrail => ApiCall.AuditTrail;
-
-		/// <inheritdoc cref="IApiCallDetails.ThreadPoolStats"/>
-		[JsonIgnore]
-		public IReadOnlyDictionary<string, ThreadPoolStatistics> ThreadPoolStats => ApiCall.ThreadPoolStats;
-
-		/// <inheritdoc cref="IApiCallDetails.SuccessOrKnownError"/>
-		[JsonIgnore]
-		public bool SuccessOrKnownError => ApiCall.SuccessOrKnownError;
-		/// <inheritdoc cref="IApiCallDetails.HttpStatusCode"/>
-		[JsonIgnore]
-		public int? HttpStatusCode => ApiCall.HttpStatusCode;
-
-		/// <inheritdoc cref="IApiCallDetails.Success"/>
-		[JsonIgnore]
-		public bool Success => ApiCall.Success;
-		/// <inheritdoc cref="IApiCallDetails.OriginalException"/>
-		[JsonIgnore]
-		public Exception OriginalException => ApiCall.OriginalException;
-		/// <inheritdoc cref="IApiCallDetails.ResponseMimeType"/>
-		[JsonIgnore]
-		public string ResponseMimeType => ApiCall.ResponseMimeType;
-		/// <inheritdoc cref="IApiCallDetails.Uri"/>
-		[JsonIgnore]
-		public Uri Uri => ApiCall.Uri;
-
-		/// <inheritdoc cref="IApiCallDetails.TransportConfiguration"/>
-		[JsonIgnore]
-		public ITransportConfiguration TransportConfiguration => ApiCall.TransportConfiguration;
-
-		/// <inheritdoc cref="IApiCallDetails.ResponseBodyInBytes"/>
-		[JsonIgnore]
-		public byte[] ResponseBodyInBytes => ApiCall.ResponseBodyInBytes;
-
-		/// <inheritdoc cref="IApiCallDetails.RequestBodyInBytes"/>
-		[JsonIgnore]
-		public byte[] RequestBodyInBytes => ApiCall.RequestBodyInBytes;
-
-		/// <inheritdoc cref="IApiCallDetails.ParsedHeaders"/>
-		[JsonIgnore]
-		public IReadOnlyDictionary<string, IEnumerable<string>> ParsedHeaders => ApiCall.ParsedHeaders;
-
-		/// <inheritdoc cref="IApiCallDetails.DebugInformation"/>
-		public override string ToString() => ApiCall.ToString();
-	}
-
+	[JsonIgnore]
+	public ApiCallDetails ApiCallDetails { get; internal set; }
 }
diff --git a/src/Elastic.Transport/StringExtensions.cs b/src/Elastic.Transport/StringExtensions.cs
deleted file mode 100644
index 389e45d..0000000
--- a/src/Elastic.Transport/StringExtensions.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-namespace Elastic.Transport
-{
-	internal static class StringExtensions
-	{
-		internal static string ToCamelCase(this string s)
-		{
-			if (string.IsNullOrEmpty(s))
-				return s;
-
-			if (!char.IsUpper(s[0]))
-				return s;
-
-			var camelCase = char.ToLowerInvariant(s[0]).ToString();
-			if (s.Length > 1)
-				camelCase += s.Substring(1);
-
-			return camelCase;
-		}
-	}
-}
diff --git a/src/Elastic.Transport/Transport.cs b/src/Elastic.Transport/Transport.cs
deleted file mode 100644
index 4db5799..0000000
--- a/src/Elastic.Transport/Transport.cs
+++ /dev/null
@@ -1,404 +0,0 @@
-// Licensed to Elasticsearch B.V under one or more agreements.
-// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
-// See the LICENSE file in the project root for more information
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Elastic.Transport.Extensions;
-using Elastic.Transport.Products;
-
-#if !DOTNETCORE
-using System.Net;
-#endif
-
-namespace Elastic.Transport
-{
-	/// <inheritdoc cref="ITransport{TConnectionSettings}" />
-	public class Transport : Transport<TransportConfiguration>
-	{
-		/// <summary>
-		///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
-		///     different
-		///     nodes
-		/// </summary>
-		/// <param name="configurationValues">The connection settings to use for this transport</param>
-		public Transport(TransportConfiguration configurationValues) : base(configurationValues)
-		{
-		}
-
-		/// <summary>
-		///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
-		///     different
-		///     nodes
-		/// </summary>
-		/// <param name="configurationValues">The connection settings to use for this transport</param>
-		/// <param name="dateTimeProvider">The date time proved to use, safe to pass null to use the default</param>
-		/// <param name="memoryStreamFactory">The memory stream provider to use, safe to pass null to use the default</param>
-		public Transport(TransportConfiguration configurationValues,
-			IDateTimeProvider dateTimeProvider = null, IMemoryStreamFactory memoryStreamFactory = null
-		)
-			: base(configurationValues, null, dateTimeProvider, memoryStreamFactory)
-		{
-		}
-
-		/// <summary>
-		///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
-		///     different
-		///     nodes
-		/// </summary>
-		/// <param name="configurationValues">The connection settings to use for this transport</param>
-		/// <param name="pipelineProvider">In charge of create a new pipeline, safe to pass null to use the default</param>
-		/// <param name="dateTimeProvider">The date time proved to use, safe to pass null to use the default</param>
-		/// <param name="memoryStreamFactory">The memory stream provider to use, safe to pass null to use the default</param>
-		internal Transport(TransportConfiguration configurationValues,
-			IRequestPipelineFactory<TransportConfiguration> pipelineProvider = null,
-			IDateTimeProvider dateTimeProvider = null, IMemoryStreamFactory memoryStreamFactory = null
-		)
-			: base(configurationValues, pipelineProvider, dateTimeProvider, memoryStreamFactory)
-		{
-		}
-	}
-
-	/// <inheritdoc cref="ITransport{TConfiguration}" />
-	public class Transport<TConfiguration> : ITransport<TConfiguration>
-		where TConfiguration : class, ITransportConfiguration
-	{
-		private readonly IProductRegistration _productRegistration;
-
-		/// <summary>
-		///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
-		///     different
-		///     nodes
-		/// </summary>
-		/// <param name="configurationValues">The connection settings to use for this transport</param>
-		public Transport(TConfiguration configurationValues) : this(configurationValues, null, null, null)
-		{
-		}
-
-		/// <summary>
-		///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
-		///     different
-		///     nodes
-		/// </summary>
-		/// <param name="configurationValues">The connection settings to use for this transport</param>
-		/// <param name="dateTimeProvider">The date time proved to use, safe to pass null to use the default</param>
-		/// <param name="memoryStreamFactory">The memory stream provider to use, safe to pass null to use the default</param>
-		public Transport(
-			TConfiguration configurationValues,
-			IDateTimeProvider dateTimeProvider = null,
-			IMemoryStreamFactory memoryStreamFactory = null)
-				: this(configurationValues, null, dateTimeProvider, memoryStreamFactory) { }
-
-		/// <summary>
-		///     Transport coordinates the client requests over the node pool nodes and is in charge of falling over on
-		///     different
-		///     nodes
-		/// </summary>
-		/// <param name="configurationValues">The connection settings to use for this transport</param>
-		/// <param name="pipelineProvider">In charge of create a new pipeline, safe to pass null to use the default</param>
-		/// <param name="dateTimeProvider">The date time proved to use, safe to pass null to use the default</param>
-		/// <param name="memoryStreamFactory">The memory stream provider to use, safe to pass null to use the default</param>
-		public Transport(
-			TConfiguration configurationValues,
-			IRequestPipelineFactory<TConfiguration> pipelineProvider = null,
-			IDateTimeProvider dateTimeProvider = null,
-			IMemoryStreamFactory memoryStreamFactory = null
-		)
-		{
-			configurationValues.ThrowIfNull(nameof(configurationValues));
-			configurationValues.NodePool.ThrowIfNull(nameof(configurationValues.NodePool));
-			configurationValues.Connection.ThrowIfNull(nameof(configurationValues.Connection));
-			configurationValues.RequestResponseSerializer.ThrowIfNull(nameof(configurationValues
-				.RequestResponseSerializer));
-
-			_productRegistration = configurationValues.ProductRegistration;
-			Settings = configurationValues;
-			PipelineProvider = pipelineProvider ?? new RequestPipelineFactory<TConfiguration>();
-			DateTimeProvider = dateTimeProvider ?? Elastic.Transport.DateTimeProvider.Default;
-			MemoryStreamFactory = memoryStreamFactory ?? configurationValues.MemoryStreamFactory;
-		}
-
-		private IDateTimeProvider DateTimeProvider { get; }
-		private IMemoryStreamFactory MemoryStreamFactory { get; }
-		private IRequestPipelineFactory<TConfiguration> PipelineProvider { get; }
-
-		/// <inheritdoc cref="ITransport{TConnectionSettings}.Settings" />
-		public TConfiguration Settings { get; }
-
-		/// <inheritdoc cref="ITransport.Request{TResponse}" />
-		public TResponse Request<TResponse>(HttpMethod method, string path, PostData data = null,
-			IRequestParameters requestParameters = null)
-			where TResponse : class, ITransportResponse, new()
-		{
-			using var pipeline =
-				PipelineProvider.Create(Settings, DateTimeProvider, MemoryStreamFactory, requestParameters);
-
-			pipeline.FirstPoolUsage(Settings.BootstrapLock);
-
-			var requestData = new RequestData(method, path, data, Settings, requestParameters, MemoryStreamFactory);
-			Settings.OnRequestDataCreated?.Invoke(requestData);
-			TResponse response = null;
-
-			var seenExceptions = new List<PipelineException>();
-
-			if (pipeline.TryGetSingleNode(out var singleNode))
-			{
-				// No value in marking a single node as dead. We have no other options!
-
-				requestData.Node = singleNode;
-
-				try
-				{
-					response = pipeline.CallProductEndpoint<TResponse>(requestData);
-				}
-				catch (PipelineException pipelineException) when (!pipelineException.Recoverable)
-				{
-					HandlePipelineException(ref response, pipelineException, pipeline, singleNode, seenExceptions);
-				}
-				catch (PipelineException pipelineException)
-				{
-					HandlePipelineException(ref response, pipelineException, pipeline, singleNode, seenExceptions);
-				}
-				catch (Exception killerException)
-				{
-					ThrowUnexpectedTransportException(killerException, seenExceptions, requestData, response, pipeline);
-				}
-			}
-			else
-				foreach (var node in pipeline.NextNode())
-				{
-					requestData.Node = node;
-					try
-					{
-						if (_productRegistration.SupportsSniff) pipeline.SniffOnStaleCluster();
-						if (_productRegistration.SupportsPing) Ping(pipeline, node);
-
-						response = pipeline.CallProductEndpoint<TResponse>(requestData);
-						if (!response.ApiCall.SuccessOrKnownError)
-						{
-							pipeline.MarkDead(node);
-							if (_productRegistration.SupportsSniff) pipeline.SniffOnConnectionFailure();
-						}
-					}
-					catch (PipelineException pipelineException) when (!pipelineException.Recoverable)
-					{
-						HandlePipelineException(ref response, pipelineException, pipeline, node, seenExceptions);
-						break;
-					}
-					catch (PipelineException pipelineException)
-					{
-						HandlePipelineException(ref response, pipelineException, pipeline, node, seenExceptions);
-					}
-					catch (Exception killerException)
-					{
-						ThrowUnexpectedTransportException(killerException, seenExceptions, requestData, response,
-							pipeline);
-					}
-
-					if (response == null || !response.ApiCall.SuccessOrKnownError) continue; // try the next node
-
-					pipeline.MarkAlive(node);
-					break;
-				}
-
-			return FinalizeResponse(requestData, pipeline, seenExceptions, response);
-		}
-
-		/// <inheritdoc cref="ITransport.RequestAsync{TResponse}" />
-		public async Task<TResponse> RequestAsync<TResponse>(HttpMethod method, string path,
-			PostData data = null, IRequestParameters requestParameters = null,
-			CancellationToken cancellationToken = default
-		)
-			where TResponse : class, ITransportResponse, new()
-		{
-			using var pipeline =
-				PipelineProvider.Create(Settings, DateTimeProvider, MemoryStreamFactory, requestParameters);
-
-			await pipeline.FirstPoolUsageAsync(Settings.BootstrapLock, cancellationToken).ConfigureAwait(false);
-
-			var requestData = new RequestData(method, path, data, Settings, requestParameters, MemoryStreamFactory);
-			Settings.OnRequestDataCreated?.Invoke(requestData);
-			TResponse response = null;
-
-			var seenExceptions = new List<PipelineException>();
-
-			if (pipeline.TryGetSingleNode(out var singleNode))
-			{
-				// No value in marking a single node as dead. We have no other options!
-
-				requestData.Node = singleNode;
-
-				try
-				{
-					response = await pipeline.CallProductEndpointAsync<TResponse>(requestData, cancellationToken)
-						.ConfigureAwait(false);
-				}
-				catch (PipelineException pipelineException) when (!pipelineException.Recoverable)
-				{
-					HandlePipelineException(ref response, pipelineException, pipeline, singleNode, seenExceptions);
-				}
-				catch (PipelineException pipelineException)
-				{
-					HandlePipelineException(ref response, pipelineException, pipeline, singleNode, seenExceptions);
-				}
-				catch (Exception killerException)
-				{
-					ThrowUnexpectedTransportException(killerException, seenExceptions, requestData, response, pipeline);
-				}
-			}
-			else
-				foreach (var node in pipeline.NextNode())
-				{
-					requestData.Node = node;
-					try
-					{
-						if (_productRegistration.SupportsSniff)
-							await pipeline.SniffOnStaleClusterAsync(cancellationToken).ConfigureAwait(false);
-						if (_productRegistration.SupportsPing)
-							await PingAsync(pipeline, node, cancellationToken).ConfigureAwait(false);
-
-						response = await pipeline.CallProductEndpointAsync<TResponse>(requestData, cancellationToken)
-							.ConfigureAwait(false);
-						if (!response.ApiCall.SuccessOrKnownError)
-						{
-							pipeline.MarkDead(node);
-							if (_productRegistration.SupportsSniff)
-								await pipeline.SniffOnConnectionFailureAsync(cancellationToken).ConfigureAwait(false);
-						}
-					}
-					catch (PipelineException pipelineException) when (!pipelineException.Recoverable)
-					{
-						HandlePipelineException(ref response, pipelineException, pipeline, node, seenExceptions);
-						break;
-					}
-					catch (PipelineException pipelineException)
-					{
-						HandlePipelineException(ref response, pipelineException, pipeline, node, seenExceptions);
-					}
-					catch (Exception killerException)
-					{
-						if (killerException is OperationCanceledException && cancellationToken.IsCancellationRequested)
-							pipeline.AuditCancellationRequested();
-
-						throw new UnexpectedTransportException(killerException, seenExceptions)
-						{
-							Request = requestData, Response = response?.ApiCall, AuditTrail = pipeline.AuditTrail
-						};
-					}
-
-					if (cancellationToken.IsCancellationRequested)
-					{
-						pipeline.AuditCancellationRequested();
-						break;
-					}
-
-					if (response == null || !response.ApiCall.SuccessOrKnownError) continue;
-
-					pipeline.MarkAlive(node);
-					break;
-				}
-
-			return FinalizeResponse(requestData, pipeline, seenExceptions, response);
-		}
-		private static void ThrowUnexpectedTransportException<TResponse>(Exception killerException,
-			List<PipelineException> seenExceptions,
-			RequestData requestData,
-			TResponse response, IRequestPipeline pipeline
-		) where TResponse : class, ITransportResponse, new() =>
-			throw new UnexpectedTransportException(killerException, seenExceptions)
-			{
-				Request = requestData, Response = response?.ApiCall, AuditTrail = pipeline.AuditTrail
-			};
-
-		private static void HandlePipelineException<TResponse>(
-			ref TResponse response, PipelineException ex, IRequestPipeline pipeline, Node node,
-			ICollection<PipelineException> seenExceptions
-		)
-			where TResponse : class, ITransportResponse, new()
-		{
-			response ??= ex.Response as TResponse;
-			pipeline.MarkDead(node);
-			seenExceptions.Add(ex);
-		}
-
-		private TResponse FinalizeResponse<TResponse>(RequestData requestData, IRequestPipeline pipeline,
-			List<PipelineException> seenExceptions,
-			TResponse response
-		) where TResponse : class, ITransportResponse, new()
-		{
-			if (requestData.Node == null) //foreach never ran
-				pipeline.ThrowNoNodesAttempted(requestData, seenExceptions);
-
-			var callDetails = GetMostRecentCallDetails(response, seenExceptions);
-			var clientException = pipeline.CreateClientException(response, callDetails, requestData, seenExceptions);
-
-			if (response?.ApiCall == null)
-				pipeline.BadResponse(ref response, callDetails, requestData, clientException);
-
-			HandleTransportException(requestData, clientException, response);
-			return response;
-		}
-
-		private static IApiCallDetails GetMostRecentCallDetails<TResponse>(TResponse response,
-			IEnumerable<PipelineException> seenExceptions)
-			where TResponse : class, ITransportResponse, new()
-		{
-			var callDetails = response?.ApiCall ?? seenExceptions.LastOrDefault(e => e.ApiCall != null)?.ApiCall;
-			return callDetails;
-		}
-
-		// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
-		private void HandleTransportException(RequestData data, Exception clientException, ITransportResponse response)
-		{
-			if (response.ApiCall is ApiCallDetails a)
-			{
-				//if original exception was not explicitly set during the pipeline
-				//set it to the TransportException we created for the bad response
-				if (clientException != null && a.OriginalException == null)
-					a.OriginalException = clientException;
-				//On .NET Core the ITransportClient implementation throws exceptions on bad responses
-				//This causes it to behave differently to .NET FULL. We already wrapped the WebException
-				//under TransportException and it exposes way more information as part of it's
-				//exception message e.g the the root cause of the server error body.
-#if !DOTNETCORE
-				if (a.OriginalException is WebException)
-					a.OriginalException = clientException;
-#endif
-			}
-
-			Settings.OnRequestCompleted?.Invoke(response.ApiCall);
-			if (data != null && clientException != null && data.ThrowExceptions) throw clientException;
-		}
-
-		private void Ping(IRequestPipeline pipeline, Node node)
-		{
-			try
-			{
-				pipeline.Ping(node);
-			}
-			catch (PipelineException e) when (e.Recoverable)
-			{
-				if (_productRegistration.SupportsSniff)
-					pipeline.SniffOnConnectionFailure();
-				throw;
-			}
-		}
-
-		private async Task PingAsync(IRequestPipeline pipeline, Node node, CancellationToken cancellationToken)
-		{
-			try
-			{
-				await pipeline.PingAsync(node, cancellationToken).ConfigureAwait(false);
-			}
-			catch (PipelineException e) when (e.Recoverable)
-			{
-				if (_productRegistration.SupportsSniff)
-					await pipeline.SniffOnConnectionFailureAsync(cancellationToken).ConfigureAwait(false);
-				throw;
-			}
-		}
-	}
-}
diff --git a/src/Elastic.Transport/TransportExtensions.cs b/src/Elastic.Transport/TransportExtensions.cs
index 2b2677e..3c14e21 100644
--- a/src/Elastic.Transport/TransportExtensions.cs
+++ b/src/Elastic.Transport/TransportExtensions.cs
@@ -5,80 +5,79 @@
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace Elastic.Transport
+namespace Elastic.Transport;
+
+/// <summary>
+///     Extends <see cref="HttpTransport" /> with some convenience methods to make it easier to perform specific requests
+/// </summary>
+public static class TransportExtensions
 {
-	/// <summary>
-	///     Extends <see cref="ITransport" /> with some convenience methods to make it easier to perform specific requests
-	/// </summary>
-	public static class TransportExtensions
-	{
-		/// <summary>Perform a GET request</summary>
-		public static TResponse Get<TResponse>(this ITransport transport, string path,
-			IRequestParameters parameters = null)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.Request<TResponse>(HttpMethod.GET, path, null, parameters);
+	/// <summary>Perform a GET request</summary>
+	public static TResponse Get<TResponse>(this HttpTransport transport, string path,
+		RequestParameters parameters = null)
+		where TResponse : TransportResponse, new() =>
+		transport.Request<TResponse>(HttpMethod.GET, path, null, parameters);
 
-		/// <summary>Perform a GET request</summary>
-		public static Task<TResponse> GetAsync<TResponse>(this ITransport transport, string path,
-			IRequestParameters parameters = null, CancellationToken cancellationToken = default)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.RequestAsync<TResponse>(HttpMethod.GET, path, null, parameters, cancellationToken);
+	/// <summary>Perform a GET request</summary>
+	public static Task<TResponse> GetAsync<TResponse>(this HttpTransport transport, string path,
+		RequestParameters parameters = null, CancellationToken cancellationToken = default)
+		where TResponse : TransportResponse, new() =>
+		transport.RequestAsync<TResponse>(HttpMethod.GET, path, null, parameters, cancellationToken);
 
-		/// <summary>Perform a HEAD request</summary>
-		public static TResponse Head<TResponse>(this ITransport transport, string path,
-			IRequestParameters parameters = null)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.Request<TResponse>(HttpMethod.HEAD, path, null, parameters);
+	/// <summary>Perform a HEAD request</summary>
+	public static TResponse Head<TResponse>(this HttpTransport transport, string path,
+		RequestParameters parameters = null)
+		where TResponse : TransportResponse, new() =>
+		transport.Request<TResponse>(HttpMethod.HEAD, path, null, parameters);
 
-		/// <summary>Perform a HEAD request</summary>
-		public static Task<TResponse> HeadAsync<TResponse>(this ITransport transport, string path,
-			IRequestParameters parameters = null, CancellationToken cancellationToken = default)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.RequestAsync<TResponse>(HttpMethod.HEAD, path, null, parameters, cancellationToken);
+	/// <summary>Perform a HEAD request</summary>
+	public static Task<TResponse> HeadAsync<TResponse>(this HttpTransport transport, string path,
+		RequestParameters parameters = null, CancellationToken cancellationToken = default)
+		where TResponse : TransportResponse, new() =>
+		transport.RequestAsync<TResponse>(HttpMethod.HEAD, path, null, parameters, cancellationToken);
 
-		/// <summary>Perform a HEAD request</summary>
-		public static VoidResponse Head(this ITransport transport, string path, IRequestParameters parameters = null) =>
-			transport.Head<VoidResponse>(path, parameters);
+	/// <summary>Perform a HEAD request</summary>
+	public static VoidResponse Head(this HttpTransport transport, string path, RequestParameters parameters = null) =>
+		transport.Head<VoidResponse>(path, parameters);
 
-		/// <summary>Perform a HEAD request</summary>
-		public static Task<VoidResponse> HeadAsync(this ITransport transport, string path,
-			IRequestParameters parameters = null, CancellationToken cancellationToken = default) =>
-			transport.HeadAsync<VoidResponse>(path, parameters, cancellationToken);
+	/// <summary>Perform a HEAD request</summary>
+	public static Task<VoidResponse> HeadAsync(this HttpTransport transport, string path,
+		RequestParameters parameters = null, CancellationToken cancellationToken = default) =>
+		transport.HeadAsync<VoidResponse>(path, parameters, cancellationToken);
 
-		/// <summary>Perform a POST request</summary>
-		public static TResponse Post<TResponse>(this ITransport transport, string path, PostData data,
-			IRequestParameters parameters = null)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.Request<TResponse>(HttpMethod.POST, path, data, parameters);
+	/// <summary>Perform a POST request</summary>
+	public static TResponse Post<TResponse>(this HttpTransport transport, string path, PostData data,
+		RequestParameters parameters = null)
+		where TResponse : TransportResponse, new() =>
+		transport.Request<TResponse>(HttpMethod.POST, path, data, parameters);
 
-		/// <summary>Perform a POST request</summary>
-		public static Task<TResponse> PostAsync<TResponse>(this ITransport transport, string path, PostData data,
-			IRequestParameters parameters = null, CancellationToken cancellationToken = default)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.RequestAsync<TResponse>(HttpMethod.POST, path, data, parameters, cancellationToken);
+	/// <summary>Perform a POST request</summary>
+	public static Task<TResponse> PostAsync<TResponse>(this HttpTransport transport, string path, PostData data,
+		RequestParameters parameters = null, CancellationToken cancellationToken = default)
+		where TResponse : TransportResponse, new() =>
+		transport.RequestAsync<TResponse>(HttpMethod.POST, path, data, parameters, cancellationToken);
 
-		/// <summary>Perform a PUT request</summary>
-		public static TResponse Put<TResponse>(this ITransport transport, string path, PostData data,
-			IRequestParameters parameters = null)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.Request<TResponse>(HttpMethod.PUT, path, data, parameters);
+	/// <summary>Perform a PUT request</summary>
+	public static TResponse Put<TResponse>(this HttpTransport transport, string path, PostData data,
+		RequestParameters parameters = null)
+		where TResponse : TransportResponse, new() =>
+		transport.Request<TResponse>(HttpMethod.PUT, path, data, parameters);
 
-		/// <summary>Perform a PUT request</summary>
-		public static Task<TResponse> PutAsync<TResponse>(this ITransport transport, string path, PostData data,
-			IRequestParameters parameters = null, CancellationToken cancellationToken = default)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.RequestAsync<TResponse>(HttpMethod.PUT, path, data, parameters, cancellationToken);
+	/// <summary>Perform a PUT request</summary>
+	public static Task<TResponse> PutAsync<TResponse>(this HttpTransport transport, string path, PostData data,
+		RequestParameters parameters = null, CancellationToken cancellationToken = default)
+		where TResponse : TransportResponse, new() =>
+		transport.RequestAsync<TResponse>(HttpMethod.PUT, path, data, parameters, cancellationToken);
 
-		/// <summary>Perform a DELETE request</summary>
-		public static TResponse Delete<TResponse>(this ITransport transport, string path, PostData data = null,
-			IRequestParameters parameters = null)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.Request<TResponse>(HttpMethod.DELETE, path, data, parameters);
+	/// <summary>Perform a DELETE request</summary>
+	public static TResponse Delete<TResponse>(this HttpTransport transport, string path, PostData data = null,
+		RequestParameters parameters = null)
+		where TResponse : TransportResponse, new() =>
+		transport.Request<TResponse>(HttpMethod.DELETE, path, data, parameters);
 
-		/// <summary>Perform a DELETE request</summary>
-		public static Task<TResponse> DeleteAsync<TResponse>(this ITransport transport, string path,
-			PostData data = null, IRequestParameters parameters = null, CancellationToken cancellationToken = default)
-			where TResponse : class, ITransportResponse, new() =>
-			transport.RequestAsync<TResponse>(HttpMethod.DELETE, path, data, parameters, cancellationToken);
-	}
+	/// <summary>Perform a DELETE request</summary>
+	public static Task<TResponse> DeleteAsync<TResponse>(this HttpTransport transport, string path,
+		PostData data = null, RequestParameters parameters = null, CancellationToken cancellationToken = default)
+		where TResponse : TransportResponse, new() =>
+		transport.RequestAsync<TResponse>(HttpMethod.DELETE, path, data, parameters, cancellationToken);
 }
diff --git a/tests/Elastic.Transport.IntegrationTests/Elastic.Transport.IntegrationTests.csproj b/tests/Elastic.Transport.IntegrationTests/Elastic.Transport.IntegrationTests.csproj
index 1c17393..0e4e2b9 100644
--- a/tests/Elastic.Transport.IntegrationTests/Elastic.Transport.IntegrationTests.csproj
+++ b/tests/Elastic.Transport.IntegrationTests/Elastic.Transport.IntegrationTests.csproj
@@ -8,9 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="5.0.1" />
-
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="Xunit.Extensions.Ordering" Version="1.4.5" />
@@ -18,7 +16,6 @@
     <PackageReference Include="coverlet.collector" Version="1.3.0" />
     <PackageReference Include="Nullean.VsTest.Pretty.TestLogger" Version="0.3.0" />
     <PackageReference Include="JunitXml.TestLogger" Version="2.1.78" />
-
     <PackageReference Include="FluentAssertions" Version="5.10.3" />
   </ItemGroup>
 
diff --git a/tests/Elastic.Transport.IntegrationTests/Http/TransferEncodingChunckedTests.cs b/tests/Elastic.Transport.IntegrationTests/Http/TransferEncodingChunckedTests.cs
index 12177d0..5e5699e 100644
--- a/tests/Elastic.Transport.IntegrationTests/Http/TransferEncodingChunckedTests.cs
+++ b/tests/Elastic.Transport.IntegrationTests/Http/TransferEncodingChunckedTests.cs
@@ -30,7 +30,7 @@ public TransferEncodingChunkedTests(TransportTestServer instance) : base(instanc
 		private static readonly PostData Body = PostData.String(BodyString);
 		private const string Path = "/chunked";
 
-		private Transport Setup(
+		private HttpTransport Setup(
 			TestableHttpConnection connection,
 			Uri proxyAddress = null,
 			bool? disableAutomaticProxyDetection = null,
@@ -47,7 +47,7 @@ private Transport Setup(
 				//make sure we the requests in debugging proxy
 				: TransportTestServer.RerouteToProxyIfNeeded(config);
 
-			return new Transport(config);
+			return new DefaultHttpTransport(config);
 		}
 
 		/// <summary>
diff --git a/tests/Elastic.Transport.IntegrationTests/Plumbing/AssemblyServerTestsBase.cs b/tests/Elastic.Transport.IntegrationTests/Plumbing/AssemblyServerTestsBase.cs
index a18c929..3efa2a1 100644
--- a/tests/Elastic.Transport.IntegrationTests/Plumbing/AssemblyServerTestsBase.cs
+++ b/tests/Elastic.Transport.IntegrationTests/Plumbing/AssemblyServerTestsBase.cs
@@ -6,13 +6,13 @@
 
 namespace Elastic.Transport.IntegrationTests.Plumbing
 {
-	public class AssemblyServerTestsBase<TServer> : IAssemblyFixture<TServer> where TServer : class, ITransportTestServer
+	public class AssemblyServerTestsBase<TServer> : IAssemblyFixture<TServer> where TServer : class, HttpTransportTestServer
 	{
 		public AssemblyServerTestsBase(TServer instance) => Server = instance;
 
 		protected TServer Server { get; }
 
-		protected Transport Transport => Server.DefaultTransport;
+		protected HttpTransport Transport => Server.DefaultTransport;
 	}
 
 	public class AssemblyServerTestsBase : AssemblyServerTestsBase<TransportTestServer>
diff --git a/tests/Elastic.Transport.IntegrationTests/Plumbing/ClassServerTestsBase.cs b/tests/Elastic.Transport.IntegrationTests/Plumbing/ClassServerTestsBase.cs
index 68291d8..7285160 100644
--- a/tests/Elastic.Transport.IntegrationTests/Plumbing/ClassServerTestsBase.cs
+++ b/tests/Elastic.Transport.IntegrationTests/Plumbing/ClassServerTestsBase.cs
@@ -6,12 +6,12 @@
 
 namespace Elastic.Transport.IntegrationTests.Plumbing
 {
-	public class ClassServerTestsBase<TServer> : IClassFixture<TServer> where TServer : class, ITransportTestServer
+	public class ClassServerTestsBase<TServer> : IClassFixture<TServer> where TServer : class, HttpTransportTestServer
 	{
 		public ClassServerTestsBase(TServer instance) => Server = instance;
 
 		protected TServer Server { get; }
 
-		protected Transport Transport => Server.DefaultTransport;
+		protected HttpTransport Transport => Server.DefaultTransport;
 	}
 }
diff --git a/tests/Elastic.Transport.IntegrationTests/Plumbing/Examples/ControllerIntegrationTests.cs b/tests/Elastic.Transport.IntegrationTests/Plumbing/Examples/ControllerIntegrationTests.cs
index 8883319..903731e 100644
--- a/tests/Elastic.Transport.IntegrationTests/Plumbing/Examples/ControllerIntegrationTests.cs
+++ b/tests/Elastic.Transport.IntegrationTests/Plumbing/Examples/ControllerIntegrationTests.cs
@@ -27,7 +27,7 @@ public ControllerIntegrationTests(TransportTestServer instance) : base(instance)
 		public async Task CanCallIntoController()
 		{
 			var response = await Transport.GetAsync<StringResponse>("/dummy/20");
-			response.Success.Should().BeTrue("{0}", response.DebugInformation);
+			response.ApiCallDetails.Success.Should().BeTrue("{0}", response.ApiCallDetails.DebugInformation);
 		}
 	}
 
diff --git a/tests/Elastic.Transport.IntegrationTests/Plumbing/Examples/EndpointIntegrationTests.cs b/tests/Elastic.Transport.IntegrationTests/Plumbing/Examples/EndpointIntegrationTests.cs
index 6aeb92c..693c8cb 100644
--- a/tests/Elastic.Transport.IntegrationTests/Plumbing/Examples/EndpointIntegrationTests.cs
+++ b/tests/Elastic.Transport.IntegrationTests/Plumbing/Examples/EndpointIntegrationTests.cs
@@ -25,7 +25,7 @@ public EndpointIntegrationTests(TransportTestServer<DummyStartup> instance) : ba
 		public async Task CanCallIntoEndpoint()
 		{
 			var response = await Transport.GetAsync<StringResponse>(DummyStartup.Endpoint);
-			response.Success.Should().BeTrue("{0}", response.DebugInformation);
+			response.ApiCallDetails.Success.Should().BeTrue("{0}", response.ApiCallDetails.DebugInformation);
 		}
 	}
 
diff --git a/tests/Elastic.Transport.IntegrationTests/Plumbing/TransportTestServer.cs b/tests/Elastic.Transport.IntegrationTests/Plumbing/TransportTestServer.cs
index a2f59dc..0b45362 100644
--- a/tests/Elastic.Transport.IntegrationTests/Plumbing/TransportTestServer.cs
+++ b/tests/Elastic.Transport.IntegrationTests/Plumbing/TransportTestServer.cs
@@ -17,11 +17,11 @@
 
 namespace Elastic.Transport.IntegrationTests.Plumbing
 {
-	public interface ITransportTestServer
+	public interface HttpTransportTestServer
 	{
 		Uri Uri { get;  }
 
-		Transport DefaultTransport { get;  }
+		HttpTransport DefaultTransport { get;  }
 	}
 
 	public class TransportTestServer : TransportTestServer<DefaultStartup>
@@ -39,12 +39,12 @@ public static TransportConfiguration RerouteToProxyIfNeeded(TransportConfigurati
 
 	}
 
-	public class TransportTestServer<TStartup> : ITransportTestServer, IDisposable, IAsyncDisposable, IAsyncLifetime
+	public class TransportTestServer<TStartup> : HttpTransportTestServer, IDisposable, IAsyncDisposable, IAsyncLifetime
 		where TStartup : class
 	{
 		private readonly IWebHost _host;
 		private Uri _uri;
-		private Transport _defaultTransport;
+		private HttpTransport _defaultTransport;
 
 		public TransportTestServer()
 		{
@@ -69,7 +69,7 @@ public Uri Uri
 			private set => _uri = value;
 		}
 
-		public Transport DefaultTransport
+		public HttpTransport DefaultTransport
 		{
 			get => _defaultTransport ?? throw new Exception($"{nameof(DefaultTransport)} is not available until {nameof(StartAsync)} is called");
 			private set => _defaultTransport = value;
@@ -81,11 +81,11 @@ public async Task<TransportTestServer<TStartup>> StartAsync(CancellationToken to
 			var port = _host.GetServerPort();
 			var url = $"http://{TransportTestServer.LocalOrProxyHost}:{port}";
 			Uri = new Uri(url);
-			DefaultTransport = CreateTransport(c => new Transport(c));
+			DefaultTransport = CreateTransport(c => new DefaultHttpTransport(c));
 			return this;
 		}
 
-		public Transport CreateTransport(Func<TransportConfiguration, Transport> create) =>
+		public HttpTransport CreateTransport(Func<TransportConfiguration, HttpTransport> create) =>
 			create(TransportTestServer.RerouteToProxyIfNeeded(new TransportConfiguration(Uri)));
 
 		public void Dispose() => _host?.Dispose();
@@ -100,7 +100,5 @@ public ValueTask DisposeAsync()
 			Dispose();
 			return ValueTask.CompletedTask;
 		}
-
-
 	}
 }
diff --git a/tests/Elastic.Transport.Tests/CodeStandards/NamingConventions.doc.cs b/tests/Elastic.Transport.Tests/CodeStandards/NamingConventions.doc.cs
index d40177d..ac1773f 100644
--- a/tests/Elastic.Transport.Tests/CodeStandards/NamingConventions.doc.cs
+++ b/tests/Elastic.Transport.Tests/CodeStandards/NamingConventions.doc.cs
@@ -24,7 +24,7 @@ [Fact] public void ClassNameContainsBaseShouldBeAbstract()
 		{
 			var exceptions = new Type[] { };
 
-			var baseClassesNotAbstract = typeof(ITransport<>).Assembly.GetTypes()
+			var baseClassesNotAbstract = typeof(HttpTransport<>).Assembly.GetTypes()
 				.Where(t => t.IsClass && !exceptions.Contains(t))
 				.Where(t => t.Name.Split('`')[0].EndsWith("Base"))
 				.Where(t => !t.IsAbstract)
@@ -36,7 +36,7 @@ [Fact] public void ClassNameContainsBaseShouldBeAbstract()
 
 		private List<Type> Scan()
 		{
-			var assembly = typeof(ITransport<>).Assembly;
+			var assembly = typeof(HttpTransport<>).Assembly;
 
 			var exceptions = new List<Type>
 			{
diff --git a/tests/Elastic.Transport.Tests/ResponseBuilderDisposeTests.cs b/tests/Elastic.Transport.Tests/ResponseBuilderDisposeTests.cs
index 21a7a03..b7a5cf5 100644
--- a/tests/Elastic.Transport.Tests/ResponseBuilderDisposeTests.cs
+++ b/tests/Elastic.Transport.Tests/ResponseBuilderDisposeTests.cs
@@ -119,25 +119,25 @@ protected override void Dispose(bool disposing)
 			}
 		}
 
-		private class TrackMemoryStreamFactory : IMemoryStreamFactory
+		private class TrackMemoryStreamFactory : MemoryStreamFactory
 		{
 			public IList<TrackDisposeStream> Created { get; } = new List<TrackDisposeStream>();
 
-			public MemoryStream Create()
+			public override MemoryStream Create()
 			{
 				var stream = new TrackDisposeStream();
 				Created.Add(stream);
 				return stream;
 			}
 
-			public MemoryStream Create(byte[] bytes)
+			public override MemoryStream Create(byte[] bytes)
 			{
 				var stream = new TrackDisposeStream(bytes);
 				Created.Add(stream);
 				return stream;
 			}
 
-			public MemoryStream Create(byte[] bytes, int index, int count)
+			public override MemoryStream Create(byte[] bytes, int index, int count)
 			{
 				var stream = new TrackDisposeStream(bytes, index, count);
 				Created.Add(stream);
diff --git a/tests/Elastic.Transport.Tests/Test.cs b/tests/Elastic.Transport.Tests/Test.cs
index 887a1cb..2e0d3be 100644
--- a/tests/Elastic.Transport.Tests/Test.cs
+++ b/tests/Elastic.Transport.Tests/Test.cs
@@ -21,7 +21,7 @@ public void Usage()
 			var product = ElasticsearchProductRegistration.Default;
 
 			var settings = new TransportConfiguration(pool, connection, serializer, product);
-			var transport = new Transport<TransportConfiguration>(settings);
+			var transport = new DefaultHttpTransport<TransportConfiguration>(settings);
 
 			var response = transport.Request<StringResponse>(HttpMethod.GET, "/");
 		}
@@ -29,7 +29,7 @@ public void Usage()
 		public void MinimalUsage()
 		{
 			var settings = new TransportConfiguration(new Uri("http://localhost:9200"));
-			var transport = new Transport(settings);
+			var transport = new DefaultHttpTransport(settings);
 
 			var response = transport.Get<StringResponse>("/");
 
@@ -40,7 +40,7 @@ public void MinimalElasticsearch()
 		{
 			var uri = new Uri("http://localhost:9200");
 			var settings = new TransportConfiguration(uri, ElasticsearchProductRegistration.Default);
-			var transport = new Transport(settings);
+			var transport = new DefaultHttpTransport(settings);
 
 			var response = transport.Get<StringResponse>("/");
 
@@ -50,9 +50,9 @@ public void MinimalElasticsearch()
 		public void MinimalUsageWithRequestParameters()
 		{
 			var settings = new TransportConfiguration(new Uri("http://localhost:9200"));
-			var transport = new Transport(settings);
+			var transport = new DefaultHttpTransport(settings);
 
-			var response = transport.Get<StringResponse>("/", new RequestParameters());
+			var response = transport.Get<StringResponse>("/", new DefaultRequestParameters());
 
 			var headResponse = transport.Head("/");
 		}
@@ -61,9 +61,9 @@ public class MyClientConfiguration : TransportConfigurationBase<MyClientConfigur
 		{
 			public MyClientConfiguration(
 				NodePool nodePool = null,
-				ITransportClient transportCLient = null,
+				TransportClient transportCLient = null,
 				Serializer requestResponseSerializer = null,
-				IProductRegistration productRegistration = null)
+				ProductRegistration productRegistration = null)
 				: base(
 					nodePool ?? new SingleNodePool(new Uri("http://default-endpoint.example"))
 					, transportCLient, requestResponseSerializer, productRegistration)
@@ -74,12 +74,12 @@ public MyClientConfiguration(
 			public MyClientConfiguration NewSettings(string value) => Assign(value, (c, v) => _setting = v);
 		}
 
-		public class MyClientRequestPipeline : RequestPipeline<MyClientConfiguration>
+		public class MyClientRequestPipeline : DefaultRequestPipeline<MyClientConfiguration>
 		{
 			public MyClientRequestPipeline(MyClientConfiguration configurationValues,
-				IDateTimeProvider dateTimeProvider, IMemoryStreamFactory memoryStreamFactory,
-				IRequestParameters requestParameters)
-				: base(configurationValues, dateTimeProvider, memoryStreamFactory, requestParameters)
+				DateTimeProvider dateTimeProvider, MemoryStreamFactory memoryStreamFactory,
+					RequestParameters requestParameters)
+						: base(configurationValues, dateTimeProvider, memoryStreamFactory, requestParameters)
 			{
 			}
 		}
@@ -88,7 +88,8 @@ public void ExtendingConfiguration()
 		{
 			var clientConfiguration = new MyClientConfiguration()
 				.NewSettings("some-value");
-			var transport = new Transport<MyClientConfiguration>(clientConfiguration);
+
+			var transport = new DefaultHttpTransport<MyClientConfiguration>(clientConfiguration);
 		}
 	}
 }
diff --git a/tests/Elastic.Transport.Tests/VirtualClusterTests.cs b/tests/Elastic.Transport.Tests/VirtualClusterTests.cs
index f7f9d23..80a2694 100644
--- a/tests/Elastic.Transport.Tests/VirtualClusterTests.cs
+++ b/tests/Elastic.Transport.Tests/VirtualClusterTests.cs
@@ -41,9 +41,9 @@ [Fact] public async Task ThrowsExceptionAfterDepleedingRules()
 
 					{ HealthyResponse, 9200, response =>
 					{
-						response.ApiCall.Success.Should().BeTrue();
-						response.ApiCall.HttpStatusCode.Should().Be(200);
-						response.ApiCall.DebugInformation.Should().Contain("x\":1");
+						response.ApiCallDetails.Success.Should().BeTrue();
+						response.ApiCallDetails.HttpStatusCode.Should().Be(200);
+						response.ApiCallDetails.DebugInformation.Should().Contain("x\":1");
 					} },
 				}
 			);
@@ -86,42 +86,42 @@ [Fact] public async Task RulesAreIgnoredAfterBeingExecuted()
 
 					{ HealthyResponse, 9200, response =>
 					{
-						response.ApiCall.Success.Should().BeTrue();
-						response.ApiCall.HttpStatusCode.Should().Be(200);
-						response.ApiCall.DebugInformation.Should().Contain("x\":1");
+						response.ApiCallDetails.Success.Should().BeTrue();
+						response.ApiCallDetails.HttpStatusCode.Should().Be(200);
+						response.ApiCallDetails.DebugInformation.Should().Contain("x\":1");
 					} },
 				},
 				new ClientCall {
 
 					{ BadResponse, 9200, response =>
 					{
-						response.ApiCall.Success.Should().BeFalse();
-						response.ApiCall.HttpStatusCode.Should().Be(500);
-						response.ApiCall.DebugInformation.Should().Contain("x\":2");
+						response.ApiCallDetails.Success.Should().BeFalse();
+						response.ApiCallDetails.HttpStatusCode.Should().Be(500);
+						response.ApiCallDetails.DebugInformation.Should().Contain("x\":2");
 					} },
 				},
 				new ClientCall {
 
 					{ BadResponse, 9200, response =>
 					{
-						response.ApiCall.HttpStatusCode.Should().Be(400);
-						response.ApiCall.DebugInformation.Should().Contain("x\":3");
+						response.ApiCallDetails.HttpStatusCode.Should().Be(400);
+						response.ApiCallDetails.DebugInformation.Should().Contain("x\":3");
 					} },
 				},
 				new ClientCall {
 
 					{ BadResponse, 9200, response =>
 					{
-						response.ApiCall.HttpStatusCode.Should().Be(400);
-						response.ApiCall.DebugInformation.Should().Contain("x\":3");
+						response.ApiCallDetails.HttpStatusCode.Should().Be(400);
+						response.ApiCallDetails.DebugInformation.Should().Contain("x\":3");
 					} },
 				},
 				new ClientCall {
 
 					{ HealthyResponse, 9200, response =>
 					{
-						response.ApiCall.HttpStatusCode.Should().Be(200);
-						response.ApiCall.DebugInformation.Should().Contain("x\":4");
+						response.ApiCallDetails.HttpStatusCode.Should().Be(200);
+						response.ApiCallDetails.DebugInformation.Should().Contain("x\":4");
 					} },
 				}
 			);