diff --git a/.gitignore b/.gitignore
index 4ee83f6..ef76fc3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -252,3 +252,4 @@ paket-files/
 *.sln.iml
 
 .vscode/
+*.orig
diff --git a/Directory.Build.props b/Directory.Build.props
new file mode 100644
index 0000000..2deb00d
--- /dev/null
+++ b/Directory.Build.props
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project>
+  <PropertyGroup>
+    <LangVersion>latest</LangVersion>
+  </PropertyGroup>
+</Project>
\ No newline at end of file
diff --git a/README.md b/README.md
index baaff62..dbcb791 100644
--- a/README.md
+++ b/README.md
@@ -29,7 +29,7 @@ Navigate the "resource groups" exposed as properties of the `connnection`:
 var installedApps = await connection.Apps.ListAsync();
 ```
 
-**To authenticate**, the `SeqConnection` constructor accepts an `apiKey` parameter (make sure the API key permits _user-level access_) or, if you want to log in with personal credentials you can `await connection.Users.Login(username, password)`.
+**To authenticate**, the `SeqConnection` constructor accepts an `apiKey` parameter (make sure the API key permits _user-level access_) or, if you want to log in with personal credentials you can `await connection.Users.LoginAsync(username, password)`.
 
 For a more complete example, see the [seq-tail app included in the source](https://github.com/datalust/seq-api/blob/master/example/SeqTail/Program.cs).
 
@@ -128,13 +128,13 @@ var events = await client.GetAsync<ResourceGroup>(root, "EventsResources");
 Use the client to navigate links from entity to entity:
 
 ```csharp
-var matched = await client.List<EventEntity>(
+var matched = await client.ListAsync<EventEntity>(
   events,
   "Items",
   new Dictionary<string, object>{{"count", 10}, {"render", true}});
 
 foreach (var match in matched)
-  Console.WriteLine(matched.RenderedMessage);
+  Console.WriteLine(match.RenderedMessage);
 ```
 
 ### Package versioning
diff --git a/Seq.Api.sln.DotSettings b/Seq.Api.sln.DotSettings
deleted file mode 100644
index d50635d..0000000
--- a/Seq.Api.sln.DotSettings
+++ /dev/null
@@ -1,2 +0,0 @@
-<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=AD/@EntryIndexedValue">AD</s:String></wpf:ResourceDictionary>
\ No newline at end of file
diff --git a/example/SeqTail/Program.cs b/example/SeqTail/Program.cs
index 1504705..162fdd1 100644
--- a/example/SeqTail/Program.cs
+++ b/example/SeqTail/Program.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Linq;
 using System.Threading.Tasks;
 using DocoptNet;
 using Seq.Api;
diff --git a/example/SeqTail/SeqTail.csproj b/example/SeqTail/SeqTail.csproj
index c5676ab..7dc54c5 100644
--- a/example/SeqTail/SeqTail.csproj
+++ b/example/SeqTail/SeqTail.csproj
@@ -24,7 +24,6 @@
     <PackageReference Include="Serilog.Formatting.Compact.Reader" Version="1.0.1" />
     <PackageReference Include="Serilog.Sinks.Console" Version="3.1.1" />
     <PackageReference Include="System.Reactive" Version="3.0.0" />
-    <PackageReference Include="Newtonsoft.Json" Version="9.0.1" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net46' ">
diff --git a/example/SignalCopy/Program.cs b/example/SignalCopy/Program.cs
index b831266..539afe6 100644
--- a/example/SignalCopy/Program.cs
+++ b/example/SignalCopy/Program.cs
@@ -5,7 +5,7 @@
 using Seq.Api.Model.Signals;
 using System.Collections.Generic;
 
-namespace SeqQuery
+namespace SignalCopy
 {
     class Program
     {
@@ -76,10 +76,9 @@ static async Task Run(string src, string srcKey, string dst, string dstKey)
 
             foreach (var signal in await srcConnection.Signals.ListAsync())
             {
-                SignalEntity target;
-                if (dstSignals.TryGetValue(signal.Title, out target))
+                if (dstSignals.TryGetValue(signal.Title, out var target))
                 {
-                    if (target.IsRestricted)
+                    if (target.IsProtected)
                     {
                         Console.WriteLine($"Skipping restricted signal '{signal.Title}' ({target.Id})");
                         continue;
diff --git a/src/Seq.Api/Client/SeqApiClient.cs b/src/Seq.Api/Client/SeqApiClient.cs
index b684fbf..d5256c4 100644
--- a/src/Seq.Api/Client/SeqApiClient.cs
+++ b/src/Seq.Api/Client/SeqApiClient.cs
@@ -26,7 +26,7 @@ public class SeqApiClient : IDisposable
         // Future versions of Seq may not completely support v1 features, however
         // providing this as an Accept header will ensure what compatibility is available
         // can be utilised.
-        const string SeqApiV5MediaType = "application/vnd.datalust.seq.v5+json";
+        const string SeqApiV6MediaType = "application/vnd.datalust.seq.v6+json";
 
         readonly HttpClient _httpClient;
         readonly CookieContainer _cookies = new CookieContainer();
@@ -36,14 +36,18 @@ public class SeqApiClient : IDisposable
                 Converters = { new StringEnumConverter(), new LinkCollectionConverter() }
             });
 
-        public SeqApiClient(string serverUrl, string apiKey = null)
+        public SeqApiClient(string serverUrl, string apiKey = null, bool useDefaultCredentials = true)
         {
             ServerUrl = serverUrl ?? throw new ArgumentNullException(nameof(serverUrl));
 
             if (!string.IsNullOrEmpty(apiKey))
                 _apiKey = apiKey;
 
-            var handler = new HttpClientHandler { CookieContainer = _cookies, UseDefaultCredentials = true };
+            var handler = new HttpClientHandler
+            {
+                CookieContainer = _cookies,
+                UseDefaultCredentials = useDefaultCredentials
+            };
 
             var baseAddress = serverUrl;
             if (!baseAddress.EndsWith("/"))
@@ -56,88 +60,95 @@ public SeqApiClient(string serverUrl, string apiKey = null)
 
         public HttpClient HttpClient => _httpClient;
 
-        public Task<RootEntity> GetRootAsync()
+        public Task<RootEntity> GetRootAsync(CancellationToken cancellationToken = default)
         {
-            return HttpGetAsync<RootEntity>("api");
+            return HttpGetAsync<RootEntity>("api", cancellationToken);
         }
 
-        public Task<TEntity> GetAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public Task<TEntity> GetAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
-            return HttpGetAsync<TEntity>(linkUri);
+            return HttpGetAsync<TEntity>(linkUri, cancellationToken);
         }
 
-        public Task<string> GetStringAsync(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public Task<string> GetStringAsync(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
-            return HttpGetStringAsync(linkUri);
+            return HttpGetStringAsync(linkUri, cancellationToken);
         }
 
-        public Task<List<TEntity>> ListAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public Task<List<TEntity>> ListAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
-            return HttpGetAsync<List<TEntity>>(linkUri);
+            return HttpGetAsync<List<TEntity>>(linkUri, cancellationToken);
         }
 
-        public async Task PostAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task PostAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Post, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, cancellationToken).ConfigureAwait(false);
             new StreamReader(stream).ReadToEnd();
         }
 
-        public async Task<TResponse> PostAsync<TEntity, TResponse>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task<TResponse> PostAsync<TEntity, TResponse>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Post, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, cancellationToken).ConfigureAwait(false);
             return _serializer.Deserialize<TResponse>(new JsonTextReader(new StreamReader(stream)));
         }
 
-        public async Task<string> PostReadStringAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task<string> PostReadStringAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Post, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, cancellationToken).ConfigureAwait(false);
             return await new StreamReader(stream).ReadToEndAsync();
         }
 
-        public async Task PutAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task<Stream> PostReadStreamAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
+        {
+            var linkUri = ResolveLink(entity, link, parameters);
+            var request = new HttpRequestMessage(HttpMethod.Post, linkUri) { Content = MakeJsonContent(content) };
+            return await HttpSendAsync(request, cancellationToken).ConfigureAwait(false);
+        }
+
+        public async Task PutAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Put, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, cancellationToken).ConfigureAwait(false);
             new StreamReader(stream).ReadToEnd();
         }
 
-        public async Task DeleteAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task DeleteAsync<TEntity>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Delete, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, cancellationToken).ConfigureAwait(false);
             new StreamReader(stream).ReadToEnd();
         }
 
-        public async Task<TResponse> DeleteAsync<TEntity, TResponse>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null)
+        public async Task<TResponse> DeleteAsync<TEntity, TResponse>(ILinked entity, string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
             var request = new HttpRequestMessage(HttpMethod.Delete, linkUri) { Content = MakeJsonContent(content) };
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, cancellationToken).ConfigureAwait(false);
             return _serializer.Deserialize<TResponse>(new JsonTextReader(new StreamReader(stream)));
         }
 
-        public async Task<ObservableStream<TEntity>> StreamAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public async Task<ObservableStream<TEntity>> StreamAsync<TEntity>(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            return await WebSocketStreamAsync(entity, link, parameters, reader => _serializer.Deserialize<TEntity>(new JsonTextReader(reader)));
+            return await WebSocketStreamAsync(entity, link, parameters, reader => _serializer.Deserialize<TEntity>(new JsonTextReader(reader)), cancellationToken);
         }
 
-        public async Task<ObservableStream<string>> StreamTextAsync(ILinked entity, string link, IDictionary<string, object> parameters = null)
+        public async Task<ObservableStream<string>> StreamTextAsync(ILinked entity, string link, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            return await WebSocketStreamAsync(entity, link, parameters, reader => reader.ReadToEnd());
+            return await WebSocketStreamAsync(entity, link, parameters, reader => reader.ReadToEnd(), cancellationToken);
         }
 
-        async Task<ObservableStream<T>> WebSocketStreamAsync<T>(ILinked entity, string link, IDictionary<string, object> parameters, Func<TextReader, T> deserialize)
+        async Task<ObservableStream<T>> WebSocketStreamAsync<T>(ILinked entity, string link, IDictionary<string, object> parameters, Func<TextReader, T> deserialize, CancellationToken cancellationToken = default)
         {
             var linkUri = ResolveLink(entity, link, parameters);
 
@@ -146,35 +157,35 @@ async Task<ObservableStream<T>> WebSocketStreamAsync<T>(ILinked entity, string l
             if (_apiKey != null)
                 socket.Options.SetRequestHeader("X-Seq-ApiKey", _apiKey);
 
-            await socket.ConnectAsync(new Uri(linkUri), CancellationToken.None);
+            await socket.ConnectAsync(new Uri(linkUri), cancellationToken);
 
             return new ObservableStream<T>(socket, deserialize);
         }
 
-        async Task<T> HttpGetAsync<T>(string url)
+        async Task<T> HttpGetAsync<T>(string url, CancellationToken cancellationToken = default)
         {
             var request = new HttpRequestMessage(HttpMethod.Get, url);
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, cancellationToken).ConfigureAwait(false);
             return _serializer.Deserialize<T>(new JsonTextReader(new StreamReader(stream)));
         }
 
-        async Task<string> HttpGetStringAsync(string url)
+        async Task<string> HttpGetStringAsync(string url, CancellationToken cancellationToken = default)
         {
             var request = new HttpRequestMessage(HttpMethod.Get, url);
-            var stream = await HttpSendAsync(request).ConfigureAwait(false);
+            var stream = await HttpSendAsync(request, cancellationToken).ConfigureAwait(false);
             return await new StreamReader(stream).ReadToEndAsync();
         }
 
-        async Task<Stream> HttpSendAsync(HttpRequestMessage request)
+        async Task<Stream> HttpSendAsync(HttpRequestMessage request, CancellationToken cancellationToken = default)
         {
             if (_apiKey != null)
                 request.Headers.Add("X-Seq-ApiKey", _apiKey);
 
-            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(SeqApiV5MediaType));
+            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue(SeqApiV6MediaType));
 
-            var response = await _httpClient.SendAsync(request).ConfigureAwait(false);
+            var response = await _httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
             var stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
-            
+
             if (response.IsSuccessStatusCode)
                 return stream;
 
@@ -186,11 +197,10 @@ async Task<Stream> HttpSendAsync(HttpRequestMessage request)
             // ReSharper disable once EmptyGeneralCatchClause
             catch { }
 
-            object error;
-            if (payload != null && payload.TryGetValue("Error", out error) && error != null)
-                throw new SeqApiException($"{(int)response.StatusCode} - {error}");
+            if (payload != null && payload.TryGetValue("Error", out var error) && error != null)
+                throw new SeqApiException($"{(int)response.StatusCode} - {error}", response.StatusCode);
 
-            throw new SeqApiException($"The Seq request failed ({(int)response.StatusCode}).");
+            throw new SeqApiException($"The Seq request failed ({(int)response.StatusCode}).", response.StatusCode);
         }
 
         HttpContent MakeJsonContent(object content)
diff --git a/src/Seq.Api/Client/SeqApiException.cs b/src/Seq.Api/Client/SeqApiException.cs
index 18a9e31..71d5966 100644
--- a/src/Seq.Api/Client/SeqApiException.cs
+++ b/src/Seq.Api/Client/SeqApiException.cs
@@ -1,12 +1,27 @@
 using System;
+using System.Net;
 
 namespace Seq.Api.Client
 {
+    /// <summary>
+    /// Thrown when an action cannot be performed.
+    /// </summary>
     public class SeqApiException : Exception
     {
-        public SeqApiException(string message)
+        /// <summary>
+        /// Construct a <see cref="SeqApiException"/> with the given message and status code.
+        /// </summary>
+        /// <param name="message">A message describing the error.</param>
+        /// <param name="statusCode">The corresponding status code returned from Seq, if available.</param>
+        public SeqApiException(string message, HttpStatusCode? statusCode)
             : base(message)
         {
+            StatusCode = statusCode;
         }
+        
+        /// <summary>
+        /// The status code returned from Seq, if available.
+        /// </summary>
+        public HttpStatusCode? StatusCode { get; }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/Model/AppInstances/AppInstanceEntity.cs b/src/Seq.Api/Model/AppInstances/AppInstanceEntity.cs
index f4921c5..cbae7ef 100644
--- a/src/Seq.Api/Model/AppInstances/AppInstanceEntity.cs
+++ b/src/Seq.Api/Model/AppInstances/AppInstanceEntity.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Newtonsoft.Json;
 using Seq.Api.Model.Apps;
 using Seq.Api.Model.Signals;
 
@@ -13,9 +14,7 @@ public AppInstanceEntity()
             InvocationOverridableSettings = new List<string>();
             InvocationOverridableSettingDefinitions = new List<AppSettingPart>();
             EventsPerSuppressionWindow = 1;
-#pragma warning disable 618
-            SignalIds = new List<string>();
-#pragma warning restore 618
+            Metrics = new AppInstanceMetricsPart();
         }
 
         public string Title { get; set; }
@@ -29,11 +28,10 @@ public AppInstanceEntity()
         public int ChannelCapacity { get; set; }
         public TimeSpan SuppressionTime { get; set; }
         public int EventsPerSuppressionWindow { get; set; }
-        public int? ProcessedEventsPerMinute { get; set; }
-
-        [Obsolete("Replaced by InputSignalExpression.")]
-        public List<string> SignalIds { get; set; }
 
         public List<AppSettingPart> InvocationOverridableSettingDefinitions { get; set; }
+
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public AppInstanceMetricsPart Metrics { get; set; }
     }
 }
diff --git a/src/Seq.Api/Model/AppInstances/AppInstanceMetricsPart.cs b/src/Seq.Api/Model/AppInstances/AppInstanceMetricsPart.cs
new file mode 100644
index 0000000..0f94b74
--- /dev/null
+++ b/src/Seq.Api/Model/AppInstances/AppInstanceMetricsPart.cs
@@ -0,0 +1,10 @@
+namespace Seq.Api.Model.AppInstances
+{
+    public class AppInstanceMetricsPart
+    {
+        public int ReceivedEventsPerMinute { get; set; }
+        public int EmittedEventsPerMinute { get; set; }
+        public long ProcessWorkingSetBytes { get; set; }
+        public bool IsRunning { get; set; }
+    }
+}
diff --git a/src/Seq.Api/Model/Backups/BackupEntity.cs b/src/Seq.Api/Model/Backups/BackupEntity.cs
index a59bd0b..4631a56 100644
--- a/src/Seq.Api/Model/Backups/BackupEntity.cs
+++ b/src/Seq.Api/Model/Backups/BackupEntity.cs
@@ -1,6 +1,4 @@
-using System;
-
-namespace Seq.Api.Model.Backups
+namespace Seq.Api.Model.Backups
 {
     public class BackupEntity : Entity
     {
diff --git a/src/Seq.Api/Model/Events/DeleteResultPart.cs b/src/Seq.Api/Model/Events/DeleteResultPart.cs
index f9e6e43..ebab4f2 100644
--- a/src/Seq.Api/Model/Events/DeleteResultPart.cs
+++ b/src/Seq.Api/Model/Events/DeleteResultPart.cs
@@ -2,6 +2,5 @@
 {
     public class DeleteResultPart
     {
-        public long DeletedEventCount { get; set; }
     }
 }
diff --git a/src/Seq.Api/Model/Inputs/ApiKeyEntity.cs b/src/Seq.Api/Model/Inputs/ApiKeyEntity.cs
index 4032d9e..058ffd3 100644
--- a/src/Seq.Api/Model/Inputs/ApiKeyEntity.cs
+++ b/src/Seq.Api/Model/Inputs/ApiKeyEntity.cs
@@ -1,28 +1,25 @@
 using System.Collections.Generic;
+using Newtonsoft.Json;
 using Seq.Api.Model.LogEvents;
+using Seq.Api.Model.Security;
 using Seq.Api.Model.Signals;
 
 namespace Seq.Api.Model.Inputs
 {
     public class ApiKeyEntity : Entity
     {
-        public ApiKeyEntity()
-        {
-            AppliedProperties = new List<InputAppliedPropertyPart>();
-            InputFilter = new SignalFilterPart();
-            Metrics = new ApiKeyMetricsPart();
-        }
-
         public string Title { get; set; }
         public string Token { get; set; }
-        public List<InputAppliedPropertyPart> AppliedProperties { get; set; }
-        public SignalFilterPart InputFilter { get; set; }
-        public bool CanActAsPrincipal { get; set; }
+        public string TokenPrefix { get; set; }
+        public List<InputAppliedPropertyPart> AppliedProperties { get; set; } = new List<InputAppliedPropertyPart>();
+        public SignalFilterPart InputFilter { get; set; } = new SignalFilterPart();
         public LogEventLevel? MinimumLevel { get; set; }
         public bool UseServerTimestamps { get; set; }
-        public int InfluxPerMinute { get; set; }
-        public int ArrivalsPerMinute { get; set; }
-        public ApiKeyMetricsPart Metrics { get; set; }
         public bool IsDefault { get; set; }
+        public string OwnerId { get; set; }
+        public HashSet<Permission> AssignedPermissions { get; set; } = new HashSet<Permission>();
+
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public ApiKeyMetricsPart Metrics { get; set; } = new ApiKeyMetricsPart();
     }
 }
diff --git a/src/Seq.Api/Model/Inputs/ApiKeyMetricsPart.cs b/src/Seq.Api/Model/Inputs/ApiKeyMetricsPart.cs
index b0c3dfd..5ac3870 100644
--- a/src/Seq.Api/Model/Inputs/ApiKeyMetricsPart.cs
+++ b/src/Seq.Api/Model/Inputs/ApiKeyMetricsPart.cs
@@ -4,5 +4,6 @@ public class ApiKeyMetricsPart
     {
         public int ArrivalsPerMinute { get; set; }
         public int InfluxPerMinute { get; set; }
+        public long IngestedBytesPerMinute { get; set; }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/Model/Monitoring/AlertPart.cs b/src/Seq.Api/Model/Monitoring/AlertPart.cs
index 6e3b8c0..cb3a9fe 100644
--- a/src/Seq.Api/Model/Monitoring/AlertPart.cs
+++ b/src/Seq.Api/Model/Monitoring/AlertPart.cs
@@ -10,6 +10,7 @@ public class AlertPart
 
         public string Id { get; set; }
         public string Condition { get; set; }
+        public string Title { get; set; }
         public TimeSpan MeasurementWindow { get; set; }
         public TimeSpan StabilizationWindow { get; set; } = TimeSpan.FromSeconds(30);
         public TimeSpan SuppressionTime { get; set; }
diff --git a/src/Seq.Api/Model/Monitoring/DashboardEntity.cs b/src/Seq.Api/Model/Monitoring/DashboardEntity.cs
index a94b268..0e932ea 100644
--- a/src/Seq.Api/Model/Monitoring/DashboardEntity.cs
+++ b/src/Seq.Api/Model/Monitoring/DashboardEntity.cs
@@ -9,6 +9,8 @@ public class DashboardEntity : Entity
 
         public string Title { get; set; }
 
+        public bool IsProtected { get; set; }
+
         public SignalExpressionPart SignalExpression { get; set; }
 
         public List<ChartPart> Charts { get; set; } = new List<ChartPart>();
diff --git a/src/Seq.Api/Model/Monitoring/MeasurementDisplayStylePart.cs b/src/Seq.Api/Model/Monitoring/MeasurementDisplayStylePart.cs
index 4c47411..75209f4 100644
--- a/src/Seq.Api/Model/Monitoring/MeasurementDisplayStylePart.cs
+++ b/src/Seq.Api/Model/Monitoring/MeasurementDisplayStylePart.cs
@@ -6,6 +6,7 @@ public class MeasurementDisplayStylePart
         public bool LineFillToZeroY { get; set; }
         public bool LineShowMarkers { get; set; } = true;
         public bool BarOverlaySum { get; set; }
+        public bool SuppressLegend { get; set; }
         public MeasurementDisplayPalette Palette { get; set; } = MeasurementDisplayPalette.Default;
     }
 }
diff --git a/src/Seq.Api/Model/Permalinks/PermalinkEntity.cs b/src/Seq.Api/Model/Permalinks/PermalinkEntity.cs
index 74ac2c9..4111112 100644
--- a/src/Seq.Api/Model/Permalinks/PermalinkEntity.cs
+++ b/src/Seq.Api/Model/Permalinks/PermalinkEntity.cs
@@ -6,6 +6,12 @@ namespace Seq.Api.Model.Permalinks
 {
     public class PermalinkEntity : Entity
     {
+        /// <summary>
+        /// When retrieving an event that _may_ be permalinked (backwards compatibility),
+        /// this hint is given by specifiying `permalinkId=unknown` in the API call.
+        /// </summary>
+        public const string UnknownId = "unknown";
+
         public string OwnerId { get; set; }
         public string EventId { get; set; }
         public DateTime CreatedUtc { get; set; }
diff --git a/src/Seq.Api/Model/Security/Permission.cs b/src/Seq.Api/Model/Security/Permission.cs
new file mode 100644
index 0000000..88486a0
--- /dev/null
+++ b/src/Seq.Api/Model/Security/Permission.cs
@@ -0,0 +1,41 @@
+namespace Seq.Api.Model.Security
+{
+    /// <summary>
+    /// A permission is an access right 1) held by a principal, and 2) demanded by an endpoint. Permissions
+    /// may be broad, such as the permission to modify administrative settings, or narrow (e.g. currently the
+    /// permission to ingest events).
+    /// </summary>
+    public enum Permission
+    {   
+        /// <summary>
+        /// A sentinel value to detect uninitialized permissions.
+        /// </summary>
+        Undefined,
+        
+        /// <summary>
+        /// Access to publicly-visible assets - the API root/metadata, HTML, JavaScript, CSS, information necessary
+        /// to initiate the login process, and so-on.
+        /// </summary>
+        Public,
+        
+        /// <summary>
+        /// Add events to the event store.
+        /// </summary>
+        Ingest,
+        
+        /// <summary>
+        /// Query events, dashboards, signals, app instances.
+        /// </summary>
+        Read,
+        
+        /// <summary>
+        /// Write-access to signals, alerts, preferences etc.
+        /// </summary>
+        Write,
+        
+        /// <summary>
+        /// Access to administrative features of Seq, management of other users, app installation, backups.
+        /// </summary>
+        Setup,
+    }
+}
diff --git a/src/Seq.Api/Model/Security/RoleEntity.cs b/src/Seq.Api/Model/Security/RoleEntity.cs
new file mode 100644
index 0000000..2d88ce2
--- /dev/null
+++ b/src/Seq.Api/Model/Security/RoleEntity.cs
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace Seq.Api.Model.Security
+{
+    public class RoleEntity : Entity
+    {
+        public string Title { get; set; }
+        public HashSet<Permission> Permissions { get; set; } = new HashSet<Permission>();
+    }
+}
diff --git a/src/Seq.Api/Model/Security/WellKnownRole.cs b/src/Seq.Api/Model/Security/WellKnownRole.cs
new file mode 100644
index 0000000..19678c6
--- /dev/null
+++ b/src/Seq.Api/Model/Security/WellKnownRole.cs
@@ -0,0 +1,8 @@
+namespace Seq.Api.Model.Security
+{
+    public static class WellKnownRole
+    {
+        public const string AdministratorRoleId = "role-administrator";
+        public const string UserRoleId = "role-user";
+    }
+}
diff --git a/src/Seq.Api/Model/Settings/SettingName.cs b/src/Seq.Api/Model/Settings/SettingName.cs
index d5cb31d..f9ab369 100644
--- a/src/Seq.Api/Model/Settings/SettingName.cs
+++ b/src/Seq.Api/Model/Settings/SettingName.cs
@@ -18,9 +18,12 @@ public enum SettingName
         LazilyFlushEventWrites,
         MasterKeyIsBackedUp,
         MinimumFreeStorageSpace,
+        NewUserShowSignalIds,
+        NewUserShowQueryIds,
+        NewUserShowDashboardIds,
         RequireApiKeyForWritingEvents,
         RawEventMaximumContentLength,
         RawPayloadMaximumContentLength,
         ThemeStyles
     }
-}
\ No newline at end of file
+}
diff --git a/src/Seq.Api/Model/Shared/ErrorPart.cs b/src/Seq.Api/Model/Shared/ErrorPart.cs
new file mode 100644
index 0000000..b16328f
--- /dev/null
+++ b/src/Seq.Api/Model/Shared/ErrorPart.cs
@@ -0,0 +1,7 @@
+namespace Seq.Api.Model.Shared
+{
+    public class ErrorPart
+    {
+        public string Error { get; set; }
+    }
+}
diff --git a/src/Seq.Api/Model/Signals/SignalEntity.cs b/src/Seq.Api/Model/Signals/SignalEntity.cs
index d8c4004..cab6ddd 100644
--- a/src/Seq.Api/Model/Signals/SignalEntity.cs
+++ b/src/Seq.Api/Model/Signals/SignalEntity.cs
@@ -1,4 +1,6 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
 
 namespace Seq.Api.Model.Signals
 {
@@ -19,12 +21,17 @@ public SignalEntity()
 
         public List<TaggedPropertyPart> TaggedProperties { get; set; }
 
-        public bool IsWatched { get; set; }
+        // ReSharper disable once UnusedMember.Global
+        [Obsolete("This member has been renamed `IsProtected` to better reflect its purpose.")]
+        [JsonProperty(DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public bool? IsRestricted { get; set; }
 
-        public bool IsRestricted { get; set; }
+        public bool IsProtected { get; set; }
 
         public SignalGrouping Grouping { get; set; }
 
         public string ExplicitGroupName { get; set; }
+
+        public string OwnerId { get; set; }
     }
 }
diff --git a/src/Seq.Api/Model/SqlQueries/SqlQueryEntity.cs b/src/Seq.Api/Model/SqlQueries/SqlQueryEntity.cs
index a09112a..289d4c1 100644
--- a/src/Seq.Api/Model/SqlQueries/SqlQueryEntity.cs
+++ b/src/Seq.Api/Model/SqlQueries/SqlQueryEntity.cs
@@ -14,6 +14,9 @@ public SqlQueryEntity()
 
         public string Sql { get; set; }
 
-        public bool Show { get; set; }
+        public bool IsProtected { get; set; }
+
+        public string OwnerId { get; set; }
+
     }
-}
\ No newline at end of file
+}
diff --git a/src/Seq.Api/Model/Users/UserEntity.cs b/src/Seq.Api/Model/Users/UserEntity.cs
index 2c186f2..4481e61 100644
--- a/src/Seq.Api/Model/Users/UserEntity.cs
+++ b/src/Seq.Api/Model/Users/UserEntity.cs
@@ -9,9 +9,9 @@ public class UserEntity : Entity
         public string DisplayName { get; set; }
         public string EmailAddress { get; set; }
         public Dictionary<string, object> Preferences { get; set; }
-        public bool IsAdministrator { get; set; }
         public string NewPassword { get; set; }
         public SignalFilterPart ViewFilter { get; set; }
         public bool MustChangePassword { get; set; }
+        public HashSet<string> RoleIds { get; set; } = new HashSet<string>();
     }
 }
diff --git a/src/Seq.Api/Model/Workspaces/WorkspaceContentPart.cs b/src/Seq.Api/Model/Workspaces/WorkspaceContentPart.cs
new file mode 100644
index 0000000..bc32a5d
--- /dev/null
+++ b/src/Seq.Api/Model/Workspaces/WorkspaceContentPart.cs
@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+
+namespace Seq.Api.Model.Workspaces
+{
+    public class WorkspaceContentPart
+    {
+        public List<string> SignalIds { get; set; } = new List<string>();
+        public List<string> QueryIds { get; set; } = new List<string>();
+        public List<string> DashboardIds { get; set; } = new List<string>();
+    }
+}
\ No newline at end of file
diff --git a/src/Seq.Api/Model/Workspaces/WorkspaceEntity.cs b/src/Seq.Api/Model/Workspaces/WorkspaceEntity.cs
new file mode 100644
index 0000000..27ed398
--- /dev/null
+++ b/src/Seq.Api/Model/Workspaces/WorkspaceEntity.cs
@@ -0,0 +1,12 @@
+namespace Seq.Api.Model.Workspaces
+{
+    public class WorkspaceEntity : Entity
+    {
+        public string Title { get; set; }
+        public string Description { get; set; }
+        public string OwnerId { get; set; }
+        public bool IsProtected { get; set; }
+
+        public WorkspaceContentPart Content { get; set; } = new WorkspaceContentPart();
+    }
+}
diff --git a/src/Seq.Api/ResourceGroups/ApiKeysResourceGroup.cs b/src/Seq.Api/ResourceGroups/ApiKeysResourceGroup.cs
index cc52a1a..0771ced 100644
--- a/src/Seq.Api/ResourceGroups/ApiKeysResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/ApiKeysResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Inputs;
 
@@ -12,35 +13,36 @@ internal ApiKeysResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<ApiKeyEntity> FindAsync(string id)
+        public async Task<ApiKeyEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<ApiKeyEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<ApiKeyEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<ApiKeyEntity>> ListAsync()
+        public async Task<List<ApiKeyEntity>> ListAsync(string ownerId = null, CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<ApiKeyEntity>("Items").ConfigureAwait(false);
+            var parameters = new Dictionary<string, object> { { "ownerId", ownerId } };
+            return await GroupListAsync<ApiKeyEntity>("Items", parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<ApiKeyEntity> TemplateAsync()
+        public async Task<ApiKeyEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<ApiKeyEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<ApiKeyEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<ApiKeyEntity> AddAsync(ApiKeyEntity entity)
+        public async Task<ApiKeyEntity> AddAsync(ApiKeyEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.PostAsync<ApiKeyEntity, ApiKeyEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await GroupCreateAsync<ApiKeyEntity, ApiKeyEntity>(entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(ApiKeyEntity entity)
+        public async Task RemoveAsync(ApiKeyEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(ApiKeyEntity entity)
+        public async Task UpdateAsync(ApiKeyEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/ApiResourceGroup.cs b/src/Seq.Api/ResourceGroups/ApiResourceGroup.cs
index 42cc2e9..9c3ef4d 100644
--- a/src/Seq.Api/ResourceGroups/ApiResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/ApiResourceGroup.cs
@@ -1,5 +1,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Client;
 using Seq.Api.Model;
@@ -18,70 +20,97 @@ internal ApiResourceGroup(string name, ISeqConnection connection)
             _connection = connection;
         }
 
-        protected SeqApiClient Client { get { return _connection.Client; } }
+        protected SeqApiClient Client => _connection.Client;
 
-        protected Task<ResourceGroup> LoadGroupAsync()
+        protected Task<ResourceGroup> LoadGroupAsync(CancellationToken cancellationToken = default)
         {
-            return _connection.LoadResourceGroupAsync(_name);
+            return _connection.LoadResourceGroupAsync(_name, cancellationToken);
         }
 
-        protected async Task<TEntity> GroupGetAsync<TEntity>(string link, IDictionary<string, object> parameters = null)
+        protected async Task<TEntity> GroupGetAsync<TEntity>(string link, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.GetAsync<TEntity>(group, link, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            return await Client.GetAsync<TEntity>(group, link, parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        protected async Task<string> GroupGetStringAsync(string link, IDictionary<string, object> parameters = null)
+        protected async Task<string> GroupGetStringAsync(string link, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.GetStringAsync(group, link, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            return await Client.GetStringAsync(group, link, parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        protected async Task<List<TEntity>> GroupListAsync<TEntity>(string link, IDictionary<string, object> parameters = null)
+        protected async Task<List<TEntity>> GroupListAsync<TEntity>(string link, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.ListAsync<TEntity>(group, link, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            return await Client.ListAsync<TEntity>(group, link, parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        protected async Task GroupPostAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task GroupPostAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            await Client.PostAsync(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            await Client.PostAsync(group, link, content, parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        protected async Task<string> GroupPostReadStringAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task<string> GroupPostReadStringAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.PostReadStringAsync(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            return await Client.PostReadStringAsync(group, link, content, parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        protected async Task<TResponse> GroupPostAsync<TEntity, TResponse>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task<Stream> GroupPostReadBytesAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.PostAsync<TEntity, TResponse>(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            return await Client.PostReadStreamAsync(group, link, content, parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        protected async Task GroupPutAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task<TResponse> GroupPostAsync<TEntity, TResponse>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            await Client.PutAsync(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            return await Client.PostAsync<TEntity, TResponse>(group, link, content, parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        protected async Task GroupDeleteAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task GroupPutAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            await Client.DeleteAsync(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            await Client.PutAsync(group, link, content, parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        protected async Task<TResponse> GroupDeleteAsync<TEntity, TResponse>(string link, TEntity content, IDictionary<string, object> parameters = null)
+        protected async Task GroupDeleteAsync<TEntity>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
         {
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.DeleteAsync<TEntity, TResponse>(group, link, content, parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            await Client.DeleteAsync(group, link, content, parameters, cancellationToken).ConfigureAwait(false);
+        }
+
+        protected async Task<TResponse> GroupDeleteAsync<TEntity, TResponse>(string link, TEntity content, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
+        {
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            return await Client.DeleteAsync<TEntity, TResponse>(group, link, content, parameters, cancellationToken).ConfigureAwait(false);
         }
 
         protected string GetLink<TEntity>(TEntity entity, string link, string orElse) where TEntity : ILinked
         {
             return entity.Links.ContainsKey(link) ? link : orElse;
         }
+
+        protected async Task<TResponse> GroupCreateAsync<TEntity, TResponse>(TEntity entity,
+            IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
+            where TEntity : ILinked
+        {
+            ILinked resource;
+            string link;
+
+            if (entity.Links.ContainsKey("Create"))
+            {
+                resource = entity;
+                link = "Create";
+            }
+            else
+            {
+                resource = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+                link = "Items";
+            }
+
+            return await Client.PostAsync<TEntity, TResponse>(resource, link, entity, parameters, cancellationToken).ConfigureAwait(false);
+        }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/AppInstancesResourceGroup.cs b/src/Seq.Api/ResourceGroups/AppInstancesResourceGroup.cs
index fe64248..32327a9 100644
--- a/src/Seq.Api/ResourceGroups/AppInstancesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/AppInstancesResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.AppInstances;
 
@@ -12,48 +13,49 @@ internal AppInstancesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<AppInstanceEntity> FindAsync(string id)
+        public async Task<AppInstanceEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<AppInstanceEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<AppInstanceEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<AppInstanceEntity>> ListAsync()
+        public async Task<List<AppInstanceEntity>> ListAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<AppInstanceEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<AppInstanceEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<AppInstanceEntity> TemplateAsync(string appId)
+        public async Task<AppInstanceEntity> TemplateAsync(string appId, CancellationToken cancellationToken = default)
         {
             if (appId == null) throw new ArgumentNullException(nameof(appId));
-            return await GroupGetAsync<AppInstanceEntity>("Template", new Dictionary<string, object> { { "appId", appId } }).ConfigureAwait(false);
+            return await GroupGetAsync<AppInstanceEntity>("Template", new Dictionary<string, object> { { "appId", appId } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<AppInstanceEntity> AddAsync(AppInstanceEntity entity, bool runOnExisting = false)
+        public async Task<AppInstanceEntity> AddAsync(AppInstanceEntity entity, bool runOnExisting = false, CancellationToken cancellationToken = default)
         {
             if (entity == null) throw new ArgumentNullException(nameof(entity));
-            return await Client.PostAsync<AppInstanceEntity, AppInstanceEntity>(entity, "Create", entity, new Dictionary<string, object> { { "runOnExisting", runOnExisting } }).ConfigureAwait(false);
+            return await Client.PostAsync<AppInstanceEntity, AppInstanceEntity>(entity, "Create", entity, new Dictionary<string, object> { { "runOnExisting", runOnExisting } }, cancellationToken)
+                .ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(AppInstanceEntity entity)
+        public async Task RemoveAsync(AppInstanceEntity entity, CancellationToken cancellationToken = default)
         {
             if (entity == null) throw new ArgumentNullException(nameof(entity));
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(AppInstanceEntity entity)
+        public async Task UpdateAsync(AppInstanceEntity entity, CancellationToken cancellationToken = default)
         {
             if (entity == null) throw new ArgumentNullException(nameof(entity));
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task InvokeAsync(AppInstanceEntity entity, string eventId, IReadOnlyDictionary<string, string> settingOverrides)
+        public async Task InvokeAsync(AppInstanceEntity entity, string eventId, IReadOnlyDictionary<string, string> settingOverrides, CancellationToken cancellationToken = default)
         {
             if (entity == null) throw new ArgumentNullException(nameof(entity));
             if (eventId == null) throw new ArgumentNullException(nameof(eventId));
 
             var postedSettings = settingOverrides ?? new Dictionary<string, string>();
-            await Client.PostAsync(entity, "Invoke", postedSettings, new Dictionary<string, object>{{"eventId", eventId}});
+            await Client.PostAsync(entity, "Invoke", postedSettings, new Dictionary<string, object>{{"eventId", eventId}}, cancellationToken);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/AppsResourceGroup.cs b/src/Seq.Api/ResourceGroups/AppsResourceGroup.cs
index 6488b3b..751d2ea 100644
--- a/src/Seq.Api/ResourceGroups/AppsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/AppsResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Apps;
 
@@ -12,44 +13,53 @@ internal AppsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<AppEntity> FindAsync(string id)
+        public async Task<AppEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<AppEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<AppEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<AppEntity>> ListAsync()
+        public async Task<List<AppEntity>> ListAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<AppEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<AppEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<AppEntity> TemplateAsync()
+        public async Task<AppEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<AppEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<AppEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<AppEntity> AddAsync(AppEntity entity)
+        public async Task<AppEntity> AddAsync(AppEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.PostAsync<AppEntity, AppEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<AppEntity, AppEntity>(entity, "Create", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(AppEntity entity)
+        public async Task RemoveAsync(AppEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(AppEntity entity)
+        public async Task UpdateAsync(AppEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<AppEntity> InstallPackageAsync(string feedId, string packageId, string version = null)
+        public async Task<AppEntity> InstallPackageAsync(string feedId, string packageId, string version = null, CancellationToken cancellationToken = default)
         {
             if (feedId == null) throw new ArgumentNullException(nameof(feedId));
             if (packageId == null) throw new ArgumentNullException(nameof(packageId));
-            var parameters = new Dictionary<string, object>{{ "feedId", feedId}, {"packageId", packageId}};
+            var parameters = new Dictionary<string, object> { { "feedId", feedId }, { "packageId", packageId } };
             if (version != null) parameters.Add("version", version);
-            return await GroupPostAsync<object, AppEntity>("InstallPackage", new object(), parameters).ConfigureAwait(false);
+            return await GroupPostAsync<object, AppEntity>("InstallPackage", new object(), parameters, cancellationToken).ConfigureAwait(false);
+        }
+
+        public async Task<AppEntity> UpdatePackageAsync(AppEntity entity, string version = null, bool force = false)
+        {
+            if (entity == null) throw new ArgumentNullException(nameof(entity));
+            var parameters = new Dictionary<string, object>();
+            if (force) parameters.Add("force", true);
+            if (version != null) parameters.Add("version", version);
+            return await Client.PostAsync<object, AppEntity>(entity, "UpdatePackage", new object(), parameters).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/BackupsResourceGroup.cs b/src/Seq.Api/ResourceGroups/BackupsResourceGroup.cs
index 3740359..08398d4 100644
--- a/src/Seq.Api/ResourceGroups/BackupsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/BackupsResourceGroup.cs
@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Backups;
 
@@ -12,15 +14,20 @@ internal BackupsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<BackupEntity> FindAsync(string id)
+        public async Task<BackupEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<BackupEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<BackupEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<BackupEntity>> ListAsync()
+        public async Task<List<BackupEntity>> ListAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<BackupEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<BackupEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
+        }
+
+        public async Task<Stream> DownloadImmediateAsync(CancellationToken cancellationToken = default)
+        {
+            return await GroupPostReadBytesAsync("Immediate", new object(), cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/DashboardsResourceGroup.cs b/src/Seq.Api/ResourceGroups/DashboardsResourceGroup.cs
index 39eee61..5b63e9b 100644
--- a/src/Seq.Api/ResourceGroups/DashboardsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/DashboardsResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Monitoring;
 
@@ -12,36 +13,36 @@ internal DashboardsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<DashboardEntity> FindAsync(string id)
+        public async Task<DashboardEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<DashboardEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<DashboardEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<DashboardEntity>> ListAsync(string ownerId = null, bool shared = false)
+        public async Task<List<DashboardEntity>> ListAsync(string ownerId = null, bool shared = false, CancellationToken cancellationToken = default)
         {
             var parameters = new Dictionary<string, object> { { "ownerId", ownerId }, { "shared", shared } };
-            return await GroupListAsync<DashboardEntity>("Items", parameters).ConfigureAwait(false);
+            return await GroupListAsync<DashboardEntity>("Items", parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<DashboardEntity> TemplateAsync()
+        public async Task<DashboardEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<DashboardEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<DashboardEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<DashboardEntity> AddAsync(DashboardEntity entity)
+        public async Task<DashboardEntity> AddAsync(DashboardEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.PostAsync<DashboardEntity, DashboardEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await GroupCreateAsync<DashboardEntity, DashboardEntity>(entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(DashboardEntity entity)
+        public async Task RemoveAsync(DashboardEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(DashboardEntity entity)
+        public async Task UpdateAsync(DashboardEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/DataResourceGroup.cs b/src/Seq.Api/ResourceGroups/DataResourceGroup.cs
index 08ab59a..c06f518 100644
--- a/src/Seq.Api/ResourceGroups/DataResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/DataResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Data;
 using Seq.Api.Model.Signals;
@@ -23,17 +24,19 @@ internal DataResourceGroup(ISeqConnection connection)
         /// <param name="unsavedSignal">A constructed signal that may not appear on the server, for example, a <see cref="SignalEntity"/> that has been
         /// created but not saved, a signal from another server, or the modified representation of an entity already persisted.</param>
         /// <param name="timeout">The query timeout; if not specified, the query will run until completion.</param>
+        /// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
         /// <returns>A structured result set.</returns>
         public async Task<QueryResultPart> QueryAsync(
             string query,
-            DateTime rangeStartUtc,
+            DateTime? rangeStartUtc = null,
             DateTime? rangeEndUtc = null,
             SignalExpressionPart signal = null,
             SignalEntity unsavedSignal = null,
-            TimeSpan? timeout = null)
+            TimeSpan? timeout = null,
+            CancellationToken cancellationToken = default)
         {
             MakeParameters(query, rangeStartUtc, rangeEndUtc, signal, unsavedSignal, timeout, out var body, out var parameters);
-            return await GroupPostAsync<SignalEntity, QueryResultPart>("Query", body, parameters).ConfigureAwait(false);
+            return await GroupPostAsync<SignalEntity, QueryResultPart>("Query", body, parameters, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -46,23 +49,25 @@ public async Task<QueryResultPart> QueryAsync(
         /// <param name="unsavedSignal">A constructed signal that may not appear on the server, for example, a <see cref="SignalEntity"/> that has been
         /// created but not saved, a signal from another server, or the modified representation of an entity already persisted.</param>
         /// <param name="timeout">The query timeout; if not specified, the query will run until completion.</param>
+        /// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
         /// <returns>A CSV result set.</returns>
         public async Task<string> QueryCsvAsync(
             string query,
-            DateTime rangeStartUtc,
+            DateTime? rangeStartUtc = null,
             DateTime? rangeEndUtc = null,
             SignalExpressionPart signal = null,
             SignalEntity unsavedSignal = null,
-            TimeSpan? timeout = null)
+            TimeSpan? timeout = null,
+            CancellationToken cancellationToken = default)
         {
             MakeParameters(query, rangeStartUtc, rangeEndUtc, signal, unsavedSignal, timeout, out var body, out var parameters);
             parameters.Add("format", "text/csv");
-            return await GroupPostReadStringAsync("Query", body, parameters).ConfigureAwait(false);
+            return await GroupPostReadStringAsync("Query", body, parameters, cancellationToken).ConfigureAwait(false);
         }
 
         static void MakeParameters(
             string query,
-            DateTime rangeStartUtc,
+            DateTime? rangeStartUtc,
             DateTime? rangeEndUtc,
             SignalExpressionPart signal,
             SignalEntity unsavedSignal,
@@ -72,22 +77,20 @@ static void MakeParameters(
         {
             parameters = new Dictionary<string, object>
             {
-                {"q", query},
-                {nameof(rangeStartUtc), rangeStartUtc}
+                {"q", query}
             };
 
+            if (rangeStartUtc != null)
+                parameters.Add(nameof(rangeStartUtc), rangeStartUtc);
+
             if (rangeEndUtc != null)
-            {
                 parameters.Add(nameof(rangeEndUtc), rangeEndUtc.Value);
-            }
+
             if (signal != null)
-            {
                 parameters.Add(nameof(signal), signal.ToString());
-            }
+
             if (timeout != null)
-            {
                 parameters.Add("timeoutMS", timeout.Value.TotalMilliseconds.ToString("0"));
-            }
 
             body = unsavedSignal ?? new SignalEntity();
         }
diff --git a/src/Seq.Api/ResourceGroups/DiagnosticsResourceGroup.cs b/src/Seq.Api/ResourceGroups/DiagnosticsResourceGroup.cs
index a983bd3..4ae8e7c 100644
--- a/src/Seq.Api/ResourceGroups/DiagnosticsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/DiagnosticsResourceGroup.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Seq.Api.Model.Diagnostics;
 
 namespace Seq.Api.ResourceGroups
@@ -10,19 +11,19 @@ internal DiagnosticsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<ServerMetricsEntity> GetServerMetricsAsync()
+        public async Task<ServerMetricsEntity> GetServerMetricsAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<ServerMetricsEntity>("ServerMetrics").ConfigureAwait(false);
+            return await GroupGetAsync<ServerMetricsEntity>("ServerMetrics", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<ServerStatusPart> GetServerStatusAsync()
+        public async Task<ServerStatusPart> GetServerStatusAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<ServerStatusPart>("ServerStatus").ConfigureAwait(false);
+            return await GroupGetAsync<ServerStatusPart>("ServerStatus", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<string> GetIngestionLogAsync()
+        public async Task<string> GetIngestionLogAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetStringAsync("IngestionLog").ConfigureAwait(false);
+            return await GroupGetStringAsync("IngestionLog", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/EntityResourceGroup.cs b/src/Seq.Api/ResourceGroups/EntityResourceGroup.cs
deleted file mode 100644
index 6bee541..0000000
--- a/src/Seq.Api/ResourceGroups/EntityResourceGroup.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Seq.Api.Model;
-
-namespace Seq.Api.ResourceGroups
-{
-    public class EntityResourceGroup : ApiResourceGroup
-    {
-        internal EntityResourceGroup(string name, ISeqConnection connection) : base(name, connection)
-        {
-        }
-
-        protected async Task<TResponse> GroupCreateAsync<TEntity, TResponse>(TEntity entity,
-            IDictionary<string, object> parameters = null) where TEntity : ILinked
-        {
-            ILinked resource;
-            string link;
-
-            if (entity.Links.ContainsKey("Create"))
-            {
-                resource = entity;
-                link = "Create";
-            }
-            else
-            {
-                resource = await LoadGroupAsync().ConfigureAwait(false);
-                link = "Items";
-            }
-
-            return await Client.PostAsync<TEntity, TResponse>(resource, link, entity, parameters).ConfigureAwait(false);
-        }
-    }
-}
diff --git a/src/Seq.Api/ResourceGroups/EventsResourceGroup.cs b/src/Seq.Api/ResourceGroups/EventsResourceGroup.cs
index 8468974..cca68e7 100644
--- a/src/Seq.Api/ResourceGroups/EventsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/EventsResourceGroup.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Events;
 using Seq.Api.Model.Shared;
@@ -16,10 +17,25 @@ internal EventsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<EventEntity> FindAsync(string id)
+        /// <summary>Find an event, given its id.</summary>
+        /// <param name="id">The id of the event to retrieve.</param>
+        /// <param name="render">If specified, the event's message template and properties will be rendered into its RenderedMessage property.</param>
+        /// <param name="permalinkId">If the request is for a permalinked event, specifying the id of the permalink here will
+        /// allow events that have otherwise been deleted to be found. The special value `"unknown"` provides backwards compatibility
+        /// with versions prior to 5.0, which did not mark permalinks explicitly.</param>
+        /// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
+        /// <returns>The event.</returns>
+        public async Task<EventEntity> FindAsync(
+            string id,
+            bool render = false,
+            string permalinkId = null,
+            CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<EventEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+
+            var parameters = new Dictionary<string, object> {{"id", id}};
+
+            return await GroupGetAsync<EventEntity>("Item", parameters, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -38,17 +54,23 @@ public async Task<EventEntity> FindAsync(string id)
         /// <param name="shortCircuitAfter">If specified, the number of events after the first match to keep searching before a partial
         /// result set is returned. Used to improve responsiveness when the result is displayed in a user interface, not typically used in
         /// batch processing scenarios.</param>
+        /// <param name="permalinkId">If the request is for a permalinked event, specifying the id of the permalink here will
+        /// allow events that have otherwise been deleted to be found. The special value `"unknown"` provides backwards compatibility
+        /// with versions prior to 5.0, which did not mark permalinks explicitly.</param>
+        /// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
         /// <returns>The complete list of events, ordered from least to most recent.</returns>
         public async Task<List<EventEntity>> ListAsync(
             SignalExpressionPart signal = null,
-            string filter = null, 
+            string filter = null,
             int count = 30,
             string startAtId = null,
             string afterId = null,
             bool render = false,
             DateTime? fromDateUtc = null,
             DateTime? toDateUtc = null,
-            int? shortCircuitAfter = null)
+            int? shortCircuitAfter = null,
+            string permalinkId = null,
+            CancellationToken cancellationToken = default)
         {
             var parameters = new Dictionary<string, object> { { "count", count } };
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
@@ -59,13 +81,14 @@ public async Task<List<EventEntity>> ListAsync(
             if (fromDateUtc != null) { parameters.Add("fromDateUtc", fromDateUtc.Value); }
             if (toDateUtc != null) { parameters.Add("toDateUtc", toDateUtc.Value); }
             if (shortCircuitAfter != null) { parameters.Add("shortCircuitAfter", shortCircuitAfter.Value); }
+            if (permalinkId != null) { parameters.Add("permalinkId", permalinkId); }
 
             var chunks = new List<List<EventEntity>>();
             var remaining = count;
 
             while (true)
             {
-                var resultSet = await GroupGetAsync<ResultSetPart>("InSignal", parameters).ConfigureAwait(false);
+                var resultSet = await GroupGetAsync<ResultSetPart>("InSignal", parameters, cancellationToken).ConfigureAwait(false);
                 chunks.Add(resultSet.Events);
                 remaining -= resultSet.Events.Count;
 
@@ -104,18 +127,24 @@ public async Task<List<EventEntity>> ListAsync(
         /// <param name="shortCircuitAfter">If specified, the number of events after the first match to keep searching before a partial
         /// result set is returned. Used to improve responsiveness when the result is displayed in a user interface, not typically used in
         /// batch processing scenarios.</param>
+        /// <param name="permalinkId">If the request is for a permalinked event, specifying the id of the permalink here will
+        /// allow events that have otherwise been deleted to be found. The special value `"unknown"` provides backwards compatibility
+        /// with versions prior to 5.0, which did not mark permalinks explicitly.</param>
+        /// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
         /// <returns>The complete list of events, ordered from least to most recent.</returns>
         public async Task<ResultSetPart> InSignalAsync(
             SignalEntity unsavedSignal = null,
             SignalExpressionPart signal = null,
-            string filter = null, 
+            string filter = null,
             int count = 30,
             string startAtId = null,
-            string afterId = null, 
+            string afterId = null,
             bool render = false,
             DateTime? fromDateUtc = null,
             DateTime? toDateUtc = null,
-            int? shortCircuitAfter = null)
+            int? shortCircuitAfter = null,
+            string permalinkId = null,
+            CancellationToken cancellationToken = default)
         {
             var parameters = new Dictionary<string, object>{{ "count", count }};
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
@@ -126,21 +155,45 @@ public async Task<ResultSetPart> InSignalAsync(
             if (fromDateUtc != null) { parameters.Add("fromDateUtc", fromDateUtc.Value); }
             if (toDateUtc != null) { parameters.Add("toDateUtc", toDateUtc.Value); }
             if (shortCircuitAfter != null) { parameters.Add("shortCircuitAfter", shortCircuitAfter.Value); }
+            if (permalinkId != null) { parameters.Add("permalinkId", permalinkId); }
 
             var body = unsavedSignal ?? new SignalEntity();
-            return await GroupPostAsync<SignalEntity, ResultSetPart>("InSignal", body, parameters).ConfigureAwait(false);
+            return await GroupPostAsync<SignalEntity, ResultSetPart>("InSignal", body, parameters, cancellationToken).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// Retrieve a list of events that match a set of conditions. The complete result is buffered into memory,
+        /// so if a large result set is expected, use InSignalAsync() and lastReadEventId to page the results.
+        /// </summary>
+        /// <param name="signal">If provided, a signal expression describing the set of events that will be filtered for the result.</param>
+        /// <param name="filter">A strict Seq filter expression to match (text expressions must be in double quotes). To
+        /// convert a "fuzzy" filter into a strict one the way the Seq UI does, use connection.Expressions.ToStrictAsync().</param>
+        /// <param name="count">The number of events to retrieve. If not specified will default to 30.</param>
+        /// <param name="startAtId">An event id from which to start searching (inclusively).</param>
+        /// <param name="afterId">An event id to search after (exclusively).</param>
+        /// <param name="render">If specified, the event's message template and properties will be rendered into its RenderedMessage property.</param>
+        /// <param name="fromDateUtc">Earliest (inclusive) date/time from which to search.</param>
+        /// <param name="toDateUtc">Latest (exclusive) date/time from which to search.</param>
+        /// <param name="shortCircuitAfter">If specified, the number of events after the first match to keep searching before a partial
+        /// result set is returned. Used to improve responsiveness when the result is displayed in a user interface, not typically used in
+        /// batch processing scenarios.</param>
+        /// <param name="permalinkId">If the request is for a permalinked event, specifying the id of the permalink here will
+        /// allow events that have otherwise been deleted to be found. The special value `"unknown"` provides backwards compatibility
+        /// with versions prior to 5.0, which did not mark permalinks explicitly.</param>
+        /// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
+        /// <returns>The complete list of events, ordered from least to most recent.</returns>
         public async Task<ResultSetPart> InSignalAsync(
             SignalExpressionPart signal,
-            string filter = null, 
+            string filter = null,
             int count = 30,
             string startAtId = null,
-            string afterId = null, 
+            string afterId = null,
             bool render = false,
             DateTime? fromDateUtc = null,
             DateTime? toDateUtc = null,
-            int? shortCircuitAfter = null)
+            int? shortCircuitAfter = null,
+            string permalinkId = null,
+            CancellationToken cancellationToken = default)
         {
             if (signal == null) throw new ArgumentNullException(nameof(signal));
 
@@ -156,8 +209,9 @@ public async Task<ResultSetPart> InSignalAsync(
             if (fromDateUtc != null) { parameters.Add("fromDateUtc", fromDateUtc.Value); }
             if (toDateUtc != null) { parameters.Add("toDateUtc", toDateUtc.Value); }
             if (shortCircuitAfter != null) { parameters.Add("shortCircuitAfter", shortCircuitAfter.Value); }
+            if (permalinkId != null) { parameters.Add("permalinkId", permalinkId); }
 
-            return await GroupGetAsync<ResultSetPart>("InSignal", parameters).ConfigureAwait(false);
+            return await GroupGetAsync<ResultSetPart>("InSignal", parameters, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -170,13 +224,15 @@ public async Task<ResultSetPart> InSignalAsync(
         /// convert a "fuzzy" filter into a strict one the way the Seq UI does, use connection.Expressions.ToStrictAsync().</param>
         /// <param name="fromDateUtc">Earliest (inclusive) date/time from which to delete.</param>
         /// <param name="toDateUtc">Latest (exclusive) date/time from which to delete.</param>
+        /// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
         /// <returns>A result carrying the count of events deleted.</returns>
         public async Task<DeleteResultPart> DeleteInSignalAsync(
             SignalEntity unsavedSignal = null,
             SignalExpressionPart signal = null,
-            string filter = null, 
+            string filter = null,
             DateTime? fromDateUtc = null,
-            DateTime? toDateUtc = null)
+            DateTime? toDateUtc = null,
+            CancellationToken cancellationToken = default)
         {
             var parameters = new Dictionary<string, object>();
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
@@ -185,7 +241,7 @@ public async Task<DeleteResultPart> DeleteInSignalAsync(
             if (toDateUtc != null) { parameters.Add("toDateUtc", toDateUtc.Value); }
 
             var body = unsavedSignal ?? new SignalEntity();
-            return await GroupDeleteAsync<SignalEntity, DeleteResultPart>("DeleteInSignal", body, parameters).ConfigureAwait(false);
+            return await GroupDeleteAsync<SignalEntity, DeleteResultPart>("DeleteInSignal", body, parameters, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -195,18 +251,20 @@ public async Task<DeleteResultPart> DeleteInSignalAsync(
         /// <param name="signal">If provided, a signal expression describing the set of events that will be filtered for the result.</param>
         /// <param name="filter">A strict Seq filter expression to match (text expressions must be in double quotes). To
         /// convert a "fuzzy" filter into a strict one the way the Seq UI does, use connection.Expressions.ToStrictAsync().</param>
+        /// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
         /// <returns>An observable that will stream events from the server to subscribers. Events will be buffered server-side until the first
         /// subscriber connects, ensure at least one subscription is made in order to avoid event loss.</returns>
         public async Task<ObservableStream<T>> StreamAsync<T>(
             SignalExpressionPart signal = null,
-            string filter = null)
+            string filter = null,
+            CancellationToken cancellationToken = default)
         {
             var parameters = new Dictionary<string, object>();
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
             if (filter != null) { parameters.Add("filter", filter); }
 
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.StreamAsync<T>(group, "Stream", parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            return await Client.StreamAsync<T>(group, "Stream", parameters, cancellationToken).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -216,18 +274,20 @@ public async Task<ObservableStream<T>> StreamAsync<T>(
         /// <param name="signal">If provided, a signal expression describing the set of events that will be filtered for the result.</param>
         /// <param name="filter">A strict Seq filter expression to match (text expressions must be in double quotes). To
         /// convert a "fuzzy" filter into a strict one the way the Seq UI does, use connection.Expressions.ToStrictAsync().</param>
+        /// <param name="cancellationToken">Token through which the operation can be cancelled.</param>
         /// <returns>An observable that will stream events from the server to subscribers. Events will be buffered server-side until the first
         /// subscriber connects, ensure at least one subscription is made in order to avoid event loss.</returns>
         public async Task<ObservableStream<string>> StreamDocumentsAsync(
             SignalExpressionPart signal = null,
-            string filter = null)
+            string filter = null,
+            CancellationToken cancellationToken = default)
         {
             var parameters = new Dictionary<string, object>();
             if (signal != null) { parameters.Add("signal", signal.ToString()); }
             if (filter != null) { parameters.Add("filter", filter); }
 
-            var group = await LoadGroupAsync().ConfigureAwait(false);
-            return await Client.StreamTextAsync(group, "Stream", parameters).ConfigureAwait(false);
+            var group = await LoadGroupAsync(cancellationToken).ConfigureAwait(false);
+            return await Client.StreamTextAsync(group, "Stream", parameters, cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/ExpressionsResourceGroup.cs b/src/Seq.Api/ResourceGroups/ExpressionsResourceGroup.cs
index c43d1c2..1088f8b 100644
--- a/src/Seq.Api/ResourceGroups/ExpressionsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/ExpressionsResourceGroup.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Expressions;
 
@@ -11,20 +12,20 @@ internal ExpressionsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public Task<ExpressionPart> ToStrictAsync(string fuzzy)
+        public Task<ExpressionPart> ToStrictAsync(string fuzzy, CancellationToken cancellationToken = default)
         {
             return GroupGetAsync<ExpressionPart>("ToStrict", new Dictionary<string, object>
             {
                 {"fuzzy", fuzzy}
-            });
+            }, cancellationToken);
         }
 
-        public Task<ExpressionPart> ToSqlAsync(string fuzzy)
+        public Task<ExpressionPart> ToSqlAsync(string fuzzy, CancellationToken cancellationToken = default)
         {
             return GroupGetAsync<ExpressionPart>("ToSql", new Dictionary<string, object>
             {
                 {"fuzzy", fuzzy}
-            });
+            }, cancellationToken);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/FeedsResourceGroup.cs b/src/Seq.Api/ResourceGroups/FeedsResourceGroup.cs
index 2e0bdec..3e0e1bb 100644
--- a/src/Seq.Api/ResourceGroups/FeedsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/FeedsResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Feeds;
 
@@ -12,35 +13,35 @@ internal FeedsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<NuGetFeedEntity> FindAsync(string id)
+        public async Task<NuGetFeedEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<NuGetFeedEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<NuGetFeedEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<NuGetFeedEntity>> ListAsync()
+        public async Task<List<NuGetFeedEntity>> ListAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<NuGetFeedEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<NuGetFeedEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<NuGetFeedEntity> TemplateAsync()
+        public async Task<NuGetFeedEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<NuGetFeedEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<NuGetFeedEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<NuGetFeedEntity> AddAsync(NuGetFeedEntity entity)
+        public async Task<NuGetFeedEntity> AddAsync(NuGetFeedEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.PostAsync<NuGetFeedEntity, NuGetFeedEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<NuGetFeedEntity, NuGetFeedEntity>(entity, "Create", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(NuGetFeedEntity entity)
+        public async Task RemoveAsync(NuGetFeedEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(NuGetFeedEntity entity)
+        public async Task UpdateAsync(NuGetFeedEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/ISeqConnection.cs b/src/Seq.Api/ResourceGroups/ISeqConnection.cs
index cbdcb0c..ca9d9e8 100644
--- a/src/Seq.Api/ResourceGroups/ISeqConnection.cs
+++ b/src/Seq.Api/ResourceGroups/ISeqConnection.cs
@@ -1,3 +1,4 @@
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Client;
 using Seq.Api.Model;
@@ -6,7 +7,7 @@ namespace Seq.Api.ResourceGroups
 {
     interface ISeqConnection
     {
-        Task<ResourceGroup> LoadResourceGroupAsync(string name);
+        Task<ResourceGroup> LoadResourceGroupAsync(string name, CancellationToken cancellationToken = default);
         SeqApiClient Client { get; }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs b/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs
index 3064d4f..af40301 100644
--- a/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/LicensesResourceGroup.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
-using Seq.Api.Model.Inputs;
 using Seq.Api.Model.License;
 
 namespace Seq.Api.ResourceGroups
@@ -13,30 +13,30 @@ internal LicensesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<LicenseEntity> FindAsync(string id)
+        public async Task<LicenseEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<LicenseEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<LicenseEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<LicenseEntity> FindCurrentAsync()
+        public async Task<LicenseEntity> FindCurrentAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<LicenseEntity>("Current").ConfigureAwait(false);
+            return await GroupGetAsync<LicenseEntity>("Current", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<LicenseEntity>> ListAsync()
+        public async Task<List<LicenseEntity>> ListAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<LicenseEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<LicenseEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(LicenseEntity entity)
+        public async Task UpdateAsync(LicenseEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task DowngradeAsync()
+        public async Task DowngradeAsync(CancellationToken cancellationToken = default)
         {
-            await GroupPostAsync("Downgrade", new object()).ConfigureAwait(false);
+            await GroupPostAsync("Downgrade", new object(), cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/PermalinksResourceGroup.cs b/src/Seq.Api/ResourceGroups/PermalinksResourceGroup.cs
index a98c098..a899911 100644
--- a/src/Seq.Api/ResourceGroups/PermalinksResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/PermalinksResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Permalinks;
 
@@ -14,54 +15,52 @@ internal PermalinksResourceGroup(ISeqConnection connection)
 
         public async Task<PermalinkEntity> FindAsync(
             string id,
-            bool includeEvent = false, 
-            bool renderEvent = false, 
-            bool includeUser = false)
+            bool includeEvent = false,
+            bool renderEvent = false,
+            CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
             var parameters = new Dictionary<string, object>
             {
                 {"id", id},
                 {"includeEvent", includeEvent},
-                {"renderEvent", renderEvent},
-                {"includeUser", includeUser}
+                {"renderEvent", renderEvent}
             };
-            return await GroupGetAsync<PermalinkEntity>("Item", parameters).ConfigureAwait(false);
+            return await GroupGetAsync<PermalinkEntity>("Item", parameters, cancellationToken).ConfigureAwait(false);
         }
 
         public async Task<List<PermalinkEntity>> ListAsync(
-            bool includeEvent = false, 
-            bool renderEvent = false, 
-            bool includeUser = false)
+            bool includeEvent = false,
+            bool renderEvent = false,
+            CancellationToken cancellationToken = default)
         {
             var parameters = new Dictionary<string, object>
             {
                 {"includeEvent", includeEvent},
-                {"renderEvent", renderEvent},
-                {"includeUser", includeUser}
+                {"renderEvent", renderEvent}
             };
 
-            return await GroupListAsync<PermalinkEntity>("Items", parameters).ConfigureAwait(false);
+            return await GroupListAsync<PermalinkEntity>("Items", parameters, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<PermalinkEntity> TemplateAsync()
+        public async Task<PermalinkEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<PermalinkEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<PermalinkEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<PermalinkEntity> AddAsync(PermalinkEntity entity)
+        public async Task<PermalinkEntity> AddAsync(PermalinkEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.PostAsync<PermalinkEntity, PermalinkEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await GroupCreateAsync<PermalinkEntity, PermalinkEntity>(entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(PermalinkEntity entity)
+        public async Task RemoveAsync(PermalinkEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(PermalinkEntity entity)
+        public async Task UpdateAsync(PermalinkEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Seq.Api/ResourceGroups/RetentionPoliciesResourceGroup.cs b/src/Seq.Api/ResourceGroups/RetentionPoliciesResourceGroup.cs
index e750e41..1e3ac18 100644
--- a/src/Seq.Api/ResourceGroups/RetentionPoliciesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/RetentionPoliciesResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Retention;
 
@@ -12,35 +13,35 @@ internal RetentionPoliciesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<RetentionPolicyEntity> FindAsync(string id)
+        public async Task<RetentionPolicyEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<RetentionPolicyEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<RetentionPolicyEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<RetentionPolicyEntity>> ListAsync()
+        public async Task<List<RetentionPolicyEntity>> ListAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<RetentionPolicyEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<RetentionPolicyEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<RetentionPolicyEntity> TemplateAsync()
+        public async Task<RetentionPolicyEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<RetentionPolicyEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<RetentionPolicyEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<RetentionPolicyEntity> AddAsync(RetentionPolicyEntity entity)
+        public async Task<RetentionPolicyEntity> AddAsync(RetentionPolicyEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.PostAsync<RetentionPolicyEntity, RetentionPolicyEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<RetentionPolicyEntity, RetentionPolicyEntity>(entity, "Create", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(RetentionPolicyEntity entity)
+        public async Task RemoveAsync(RetentionPolicyEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(RetentionPolicyEntity entity)
+        public async Task UpdateAsync(RetentionPolicyEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/SettingsResourceGroup.cs b/src/Seq.Api/ResourceGroups/SettingsResourceGroup.cs
index 1ec5292..9968d1c 100644
--- a/src/Seq.Api/ResourceGroups/SettingsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/SettingsResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Settings;
 
@@ -12,40 +13,50 @@ internal SettingsResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<SettingEntity> FindAsync(string id)
+        public async Task<SettingEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<SettingEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<SettingEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<SettingEntity> FindNamedAsync(SettingName name)
+        public async Task<SettingEntity> FindNamedAsync(SettingName name, CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<SettingEntity>(name.ToString()).ConfigureAwait(false);
+            return await GroupGetAsync<SettingEntity>(name.ToString(), cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<SettingEntity>> ListAsync()
+        public async Task<List<SettingEntity>> ListAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<SettingEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<SettingEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<SettingEntity> TemplateAsync()
+        public async Task<SettingEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<SettingEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<SettingEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<SettingEntity> AddAsync(SettingEntity entity)
+        public async Task<SettingEntity> AddAsync(SettingEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.PostAsync<SettingEntity, SettingEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<SettingEntity, SettingEntity>(entity, "Create", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(SettingEntity entity)
+        public async Task RemoveAsync(SettingEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(SettingEntity entity)
+        public async Task UpdateAsync(SettingEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
+        }
+
+        public async Task<InternalErrorReportingSettingsPart> GetInternalErrorReportingAsync()
+        {
+            return await GroupGetAsync<InternalErrorReportingSettingsPart>("InternalErrorReporting").ConfigureAwait(false);
+        }
+
+        public async Task UpdateInternalErrorReportingAsync(InternalErrorReportingSettingsPart internalErrorReporting)
+        {
+            await GroupPutAsync("InternalErrorReporting", internalErrorReporting).ConfigureAwait(false);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/Seq.Api/ResourceGroups/SignalsResourceGroup.cs b/src/Seq.Api/ResourceGroups/SignalsResourceGroup.cs
index 9a4f178..594143c 100644
--- a/src/Seq.Api/ResourceGroups/SignalsResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/SignalsResourceGroup.cs
@@ -1,46 +1,48 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Signals;
 
 namespace Seq.Api.ResourceGroups
 {
-    public class SignalsResourceGroup : EntityResourceGroup
+    public class SignalsResourceGroup : ApiResourceGroup
     {
         internal SignalsResourceGroup(ISeqConnection connection)
             : base("Signals", connection)
         {
         }
 
-        public async Task<SignalEntity> FindAsync(string id)
+        public async Task<SignalEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<SignalEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<SignalEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<SignalEntity>> ListAsync()
+        public async Task<List<SignalEntity>> ListAsync(string ownerId = null, bool shared = false, CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<SignalEntity>("Items").ConfigureAwait(false);
+            var parameters = new Dictionary<string, object> { { "ownerId", ownerId }, { "shared", shared } };
+            return await GroupListAsync<SignalEntity>("Items", parameters, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<SignalEntity> TemplateAsync()
+        public async Task<SignalEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<SignalEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<SignalEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<SignalEntity> AddAsync(SignalEntity entity)
+        public async Task<SignalEntity> AddAsync(SignalEntity entity, CancellationToken cancellationToken = default)
         {
-            return await GroupCreateAsync<SignalEntity, SignalEntity>(entity).ConfigureAwait(false);
+            return await GroupCreateAsync<SignalEntity, SignalEntity>(entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(SignalEntity entity)
+        public async Task RemoveAsync(SignalEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(SignalEntity entity)
+        public async Task UpdateAsync(SignalEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/src/Seq.Api/ResourceGroups/SqlQueriesResourceGroup.cs b/src/Seq.Api/ResourceGroups/SqlQueriesResourceGroup.cs
index 3b84725..7d5aac3 100644
--- a/src/Seq.Api/ResourceGroups/SqlQueriesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/SqlQueriesResourceGroup.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.SqlQueries;
 
@@ -12,35 +13,36 @@ internal SqlQueriesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<SqlQueryEntity> FindAsync(string id)
+        public async Task<SqlQueryEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<SqlQueryEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<SqlQueryEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<SqlQueryEntity>> ListAsync()
+        public async Task<List<SqlQueryEntity>> ListAsync(string ownerId = null, bool shared = false, CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<SqlQueryEntity>("Items").ConfigureAwait(false);
+            var parameters = new Dictionary<string, object> { { "ownerId", ownerId }, { "shared", shared } };
+            return await GroupListAsync<SqlQueryEntity>("Items", parameters, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<SqlQueryEntity> TemplateAsync()
+        public async Task<SqlQueryEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<SqlQueryEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<SqlQueryEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<SqlQueryEntity> AddAsync(SqlQueryEntity entity)
+        public async Task<SqlQueryEntity> AddAsync(SqlQueryEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.PostAsync<SqlQueryEntity, SqlQueryEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await GroupCreateAsync<SqlQueryEntity, SqlQueryEntity>(entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(SqlQueryEntity entity)
+        public async Task RemoveAsync(SqlQueryEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(SqlQueryEntity entity)
+        public async Task UpdateAsync(SqlQueryEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/UpdatesResourceGroup.cs b/src/Seq.Api/ResourceGroups/UpdatesResourceGroup.cs
index 157adb5..953d136 100644
--- a/src/Seq.Api/ResourceGroups/UpdatesResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/UpdatesResourceGroup.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Model.Updates;
 
@@ -11,9 +12,9 @@ internal UpdatesResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<List<AvailableUpdateEntity>> ListAsync()
+        public async Task<List<AvailableUpdateEntity>> ListAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<AvailableUpdateEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<AvailableUpdateEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/UsersResourceGroup.cs b/src/Seq.Api/ResourceGroups/UsersResourceGroup.cs
index 83baf25..2f94120 100644
--- a/src/Seq.Api/ResourceGroups/UsersResourceGroup.cs
+++ b/src/Seq.Api/ResourceGroups/UsersResourceGroup.cs
@@ -3,6 +3,7 @@
 using System.Threading.Tasks;
 using Seq.Api.Model.Users;
 using System.Linq;
+using System.Threading;
 using Seq.Api.Client;
 
 namespace Seq.Api.ResourceGroups
@@ -14,69 +15,69 @@ internal UsersResourceGroup(ISeqConnection connection)
         {
         }
 
-        public async Task<UserEntity> FindAsync(string id)
+        public async Task<UserEntity> FindAsync(string id, CancellationToken cancellationToken = default)
         {
             if (id == null) throw new ArgumentNullException(nameof(id));
-            return await GroupGetAsync<UserEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+            return await GroupGetAsync<UserEntity>("Item", new Dictionary<string, object> { { "id", id } }, cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> FindCurrentAsync()
+        public async Task<UserEntity> FindCurrentAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<UserEntity>("Current").ConfigureAwait(false);
+            return await GroupGetAsync<UserEntity>("Current", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<List<UserEntity>> ListAsync()
+        public async Task<List<UserEntity>> ListAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupListAsync<UserEntity>("Items").ConfigureAwait(false);
+            return await GroupListAsync<UserEntity>("Items", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> TemplateAsync()
+        public async Task<UserEntity> TemplateAsync(CancellationToken cancellationToken = default)
         {
-            return await GroupGetAsync<UserEntity>("Template").ConfigureAwait(false);
+            return await GroupGetAsync<UserEntity>("Template", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> AddAsync(UserEntity entity)
+        public async Task<UserEntity> AddAsync(UserEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.PostAsync<UserEntity, UserEntity>(entity, "Create", entity).ConfigureAwait(false);
+            return await Client.PostAsync<UserEntity, UserEntity>(entity, "Create", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task RemoveAsync(UserEntity entity)
+        public async Task RemoveAsync(UserEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.DeleteAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task UpdateAsync(UserEntity entity)
+        public async Task UpdateAsync(UserEntity entity, CancellationToken cancellationToken = default)
         {
-            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+            await Client.PutAsync(entity, "Self", entity, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> LoginAsync(string username, string password)
+        public async Task<UserEntity> LoginAsync(string username, string password, CancellationToken cancellationToken = default)
         {
             if (username == null) throw new ArgumentNullException(nameof(username));
             if (password == null) throw new ArgumentNullException(nameof(password));
             var credentials = new CredentialsPart {Username = username, Password = password};
-            return await GroupPostAsync<CredentialsPart, UserEntity>("Login", credentials).ConfigureAwait(false);
+            return await GroupPostAsync<CredentialsPart, UserEntity>("Login", credentials, cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task LogoutAsync()
+        public async Task LogoutAsync(CancellationToken cancellationToken = default)
         {
-            await GroupPostAsync("Logout", new object()).ConfigureAwait(false);
+            await GroupPostAsync("Logout", new object(), cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<SearchHistoryEntity> GetSearchHistoryAsync(UserEntity entity)
+        public async Task<SearchHistoryEntity> GetSearchHistoryAsync(UserEntity entity, CancellationToken cancellationToken = default)
         {
-            return await Client.GetAsync<SearchHistoryEntity>(entity, "SearchHistory").ConfigureAwait(false);
+            return await Client.GetAsync<SearchHistoryEntity>(entity, "SearchHistory", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public async Task<UserEntity> LoginWindowsIntegratedAsync()
+        public async Task<UserEntity> LoginWindowsIntegratedAsync(CancellationToken cancellationToken = default)
         {
-            var providers = await GroupGetAsync<AuthProvidersPart>("AuthenticationProviders").ConfigureAwait(false);
+            var providers = await GroupGetAsync<AuthProvidersPart>("AuthenticationProviders", cancellationToken: cancellationToken).ConfigureAwait(false);
             var provider = providers.Providers.SingleOrDefault(p => p.Name == "Integrated Windows Authentication");
             if (provider == null)
-                throw new SeqApiException("The Integrated Windows Authentication provider is not available.");
-            var response = await Client.HttpClient.GetAsync(provider.Url).ConfigureAwait(false);
+                throw new SeqApiException("The Integrated Windows Authentication provider is not available.", null);
+            var response = await Client.HttpClient.GetAsync(provider.Url, cancellationToken).ConfigureAwait(false);
             response.EnsureSuccessStatusCode();
-            return await FindCurrentAsync().ConfigureAwait(false);
+            return await FindCurrentAsync(cancellationToken).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Seq.Api/ResourceGroups/WorkspacesResourceGroup.cs b/src/Seq.Api/ResourceGroups/WorkspacesResourceGroup.cs
new file mode 100644
index 0000000..2dd6109
--- /dev/null
+++ b/src/Seq.Api/ResourceGroups/WorkspacesResourceGroup.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Seq.Api.Model.Workspaces;
+
+namespace Seq.Api.ResourceGroups
+{
+    public class WorkspacesResourceGroup : ApiResourceGroup
+    {
+        internal WorkspacesResourceGroup(ISeqConnection connection)
+            : base("Workspaces", connection)
+        {
+        }
+
+        public async Task<WorkspaceEntity> FindAsync(string id)
+        {
+            if (id == null) throw new ArgumentNullException(nameof(id));
+            return await GroupGetAsync<WorkspaceEntity>("Item", new Dictionary<string, object> { { "id", id } }).ConfigureAwait(false);
+        }
+
+        public async Task<List<WorkspaceEntity>> ListAsync(string ownerId = null, bool shared = false)
+        {
+            var parameters = new Dictionary<string, object> { { "ownerId", ownerId }, { "shared", shared } };
+            return await GroupListAsync<WorkspaceEntity>("Items", parameters).ConfigureAwait(false);
+        }
+
+        public async Task<WorkspaceEntity> TemplateAsync()
+        {
+            return await GroupGetAsync<WorkspaceEntity>("Template").ConfigureAwait(false);
+        }
+
+        public async Task<WorkspaceEntity> AddAsync(WorkspaceEntity entity)
+        {
+            return await GroupCreateAsync<WorkspaceEntity, WorkspaceEntity>(entity).ConfigureAwait(false);
+        }
+
+        public async Task RemoveAsync(WorkspaceEntity entity)
+        {
+            await Client.DeleteAsync(entity, "Self", entity).ConfigureAwait(false);
+        }
+
+        public async Task UpdateAsync(WorkspaceEntity entity)
+        {
+            await Client.PutAsync(entity, "Self", entity).ConfigureAwait(false);
+        }
+    }
+}
diff --git a/src/Seq.Api/Seq.Api.csproj b/src/Seq.Api/Seq.Api.csproj
index 0b4a849..e8b24b0 100644
--- a/src/Seq.Api/Seq.Api.csproj
+++ b/src/Seq.Api/Seq.Api.csproj
@@ -1,37 +1,27 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <Description>Client library for the Seq HTTP API.</Description>
-    <VersionPrefix>4.2.2</VersionPrefix>
+    <VersionPrefix>5.0.0</VersionPrefix>
     <Authors>Datalust;Contributors</Authors>
-    <TargetFrameworks>netstandard1.3;net452</TargetFrameworks>
-    <NoWarn>$(NoWarn);CS1591</NoWarn>
+    <TargetFrameworks>netstandard1.3;net46;netstandard2.0</TargetFrameworks>
+    <NoWarn>$(NoWarn);CS1591;CS1573</NoWarn>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <AssemblyName>Seq.Api</AssemblyName>
     <PackageId>Seq.Api</PackageId>
     <PackageTags>seq</PackageTags>
-    <Copyright>Copyright © 2014-2017 Datalust Pty Ltd and Contributors</Copyright>
+    <Copyright>Copyright © 2014-2018 Datalust Pty Ltd and Contributors</Copyright>
     <PackageIconUrl>https://getseq.net/images/seq-nuget.png</PackageIconUrl>
     <PackageProjectUrl>https://github.com/datalust/seq-api</PackageProjectUrl>
     <PackageLicenseUrl>http://www.apache.org/licenses/LICENSE-2.0</PackageLicenseUrl>
     <RootNamespace>Seq.Api</RootNamespace>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(TargetFramework)' == 'net452' ">
-    <DisableImplicitFrameworkReferences>true</DisableImplicitFrameworkReferences>
+    <LangVersion>7.1</LangVersion>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="Newtonsoft.Json" Version="9.0.1" />
+    <PackageReference Include="Newtonsoft.Json" Version="10.0.3" />
+    <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
     <PackageReference Include="Tavis.UriTemplates" Version="1.1.1" />
-  </ItemGroup>
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
     <PackageReference Include="System.Collections.Concurrent" Version="4.3.0" />
     <PackageReference Include="System.Net.Http" Version="4.3.3" />
-    <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.1" />
-  </ItemGroup>
-  <ItemGroup Condition=" '$(TargetFramework)' == 'net452' ">
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-    <Reference Include="Microsoft.CSharp" />
-    <Reference Include="System.Net.Http" />
   </ItemGroup>
-</Project>
+</Project>
\ No newline at end of file
diff --git a/src/Seq.Api/SeqConnection.cs b/src/Seq.Api/SeqConnection.cs
index 5d611b2..6d3e722 100644
--- a/src/Seq.Api/SeqConnection.cs
+++ b/src/Seq.Api/SeqConnection.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Threading;
 using System.Threading.Tasks;
 using Seq.Api.Client;
 using Seq.Api.Model;
@@ -10,16 +11,15 @@ namespace Seq.Api
 {
     public class SeqConnection : ISeqConnection
     {
-        readonly SeqApiClient _client;
         readonly ConcurrentDictionary<string, Task<ResourceGroup>> _resourceGroups = new ConcurrentDictionary<string, Task<ResourceGroup>>();
         readonly Lazy<Task<RootEntity>> _root;
 
-        public SeqConnection(string serverUrl, string apiKey = null)
+        public SeqConnection(string serverUrl, string apiKey = null, bool useDefaultCredentials = true)
         {
             if (serverUrl == null) throw new ArgumentNullException(nameof(serverUrl));
-            _client = new SeqApiClient(serverUrl, apiKey);
-            
-            _root = new Lazy<Task<RootEntity>>(() => _client.GetRootAsync());
+            Client = new SeqApiClient(serverUrl, apiKey, useDefaultCredentials);
+
+            _root = new Lazy<Task<RootEntity>>(() => Client.GetRootAsync());
         }
 
         public ApiKeysResourceGroup ApiKeys => new ApiKeysResourceGroup(this);
@@ -52,20 +52,24 @@ public SeqConnection(string serverUrl, string apiKey = null)
 
         public SignalsResourceGroup Signals => new SignalsResourceGroup(this);
 
+        public SqlQueriesResourceGroup SqlQueries => new SqlQueriesResourceGroup(this);
+
         public UpdatesResourceGroup Updates => new UpdatesResourceGroup(this);
 
         public UsersResourceGroup Users => new UsersResourceGroup(this);
 
-        public async Task<ResourceGroup> LoadResourceGroupAsync(string name)
+        public WorkspacesResourceGroup Workspaces => new WorkspacesResourceGroup(this);
+
+        public async Task<ResourceGroup> LoadResourceGroupAsync(string name, CancellationToken cancellationToken = default)
         {
-            return await _resourceGroups.GetOrAdd(name, ResourceGroupFactory).ConfigureAwait(false);
+            return await _resourceGroups.GetOrAdd(name, s => ResourceGroupFactory(s, cancellationToken)).ConfigureAwait(false);
         }
 
-        async Task<ResourceGroup> ResourceGroupFactory(string name)
+        async Task<ResourceGroup> ResourceGroupFactory(string name, CancellationToken cancellationToken = default)
         {
-            return await _client.GetAsync<ResourceGroup>(await _root.Value, name + "Resources").ConfigureAwait(false);
+            return await Client.GetAsync<ResourceGroup>(await _root.Value, name + "Resources", cancellationToken: cancellationToken).ConfigureAwait(false);
         }
 
-        public SeqApiClient Client => _client;
+        public SeqApiClient Client { get; }
     }
 }
diff --git a/src/Seq.Api/Streams/ObservableStream.cs b/src/Seq.Api/Streams/ObservableStream.cs
index ac96d4d..0ddc419 100644
--- a/src/Seq.Api/Streams/ObservableStream.cs
+++ b/src/Seq.Api/Streams/ObservableStream.cs
@@ -38,11 +38,8 @@ public sealed partial class ObservableStream<T> : IObservable<T>, IDisposable
 
         internal ObservableStream(ClientWebSocket socket, Func<TextReader, T> deserialize)
         {
-            if (socket == null) throw new ArgumentNullException(nameof(socket));
-            if (deserialize == null) throw new ArgumentNullException(nameof(deserialize));
-
-            _deserialize = deserialize;
-            _socket = socket;
+            _deserialize = deserialize ?? throw new ArgumentNullException(nameof(deserialize));
+            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
         }
 
         public IDisposable Subscribe(IObserver<T> observer)
@@ -179,7 +176,7 @@ void End()
                 OnError(exceptions);
         }
 
-        void OnError(IList<Exception> exceptions)
+        static void OnError(IEnumerable<Exception> exceptions)
         {
             // This will hit TaskScheduler.UnobservedTaskException
             throw new AggregateException("At least one observer failed to accept the event", exceptions);            
@@ -205,10 +202,21 @@ public void Dispose()
                     }
                 }
             }
-            catch { }
+            catch
+            {
+                // Don't mask exceptions by throwing here during unwinding
+            }
 
             if (_run != null)
-                _run.ConfigureAwait(false).GetAwaiter().GetResult();
+            {
+                try
+                {
+                    _run.ConfigureAwait(false).GetAwaiter().GetResult();
+                }
+                catch (TaskCanceledException)
+                {
+                }
+            }
 
             _socket.Dispose();
         }
diff --git a/test/Seq.Api.Tests/Properties/AssemblyInfo.cs b/test/Seq.Api.Tests/Properties/AssemblyInfo.cs
deleted file mode 100644
index 083fd7a..0000000
--- a/test/Seq.Api.Tests/Properties/AssemblyInfo.cs
+++ /dev/null
@@ -1,15 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-// General Information about an assembly is controlled through the following
-// set of attributes. Change these attribute values to modify the information
-// associated with an assembly.
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("")]
-[assembly: AssemblyProduct("Seq.Api.Tests")]
-[assembly: AssemblyTrademark("")]
-
-// Setting ComVisible to false makes the types in this assembly not visible
-// to COM components.  If you need to access a type in this assembly from
-// COM, set the ComVisible attribute to true on that type.
-[assembly: ComVisible(false)]
diff --git a/test/Seq.Api.Tests/Seq.Api.Tests.csproj b/test/Seq.Api.Tests/Seq.Api.Tests.csproj
index 397fd34..b573d26 100644
--- a/test/Seq.Api.Tests/Seq.Api.Tests.csproj
+++ b/test/Seq.Api.Tests/Seq.Api.Tests.csproj
@@ -1,15 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netcoreapp1.0;net46</TargetFrameworks>
-    <AssemblyName>Seq.Api.Tests</AssemblyName>
-    <PackageId>Seq.Api.Tests</PackageId>
+    <TargetFrameworks>net46;netcoreapp2.0</TargetFrameworks>
     <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
-    <PackageTargetFallback Condition=" '$(TargetFramework)' == 'netcoreapp1.0' ">$(PackageTargetFallback);dnxcore50;portable-net45+win8</PackageTargetFallback>
-    <RuntimeFrameworkVersion Condition=" '$(TargetFramework)' == 'netcoreapp1.0' ">1.0.4</RuntimeFrameworkVersion>
-    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
-    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
-    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
   </PropertyGroup>
 
   <ItemGroup>
@@ -27,4 +20,4 @@
     <Reference Include="Microsoft.CSharp" />
   </ItemGroup>
 
-</Project>
+</Project>
\ No newline at end of file