diff --git a/src/RestSharp/Extensions/AsyncHelpers.cs b/src/RestSharp/Extensions/AsyncHelpers.cs
new file mode 100644
index 000000000..1b90277f0
--- /dev/null
+++ b/src/RestSharp/Extensions/AsyncHelpers.cs
@@ -0,0 +1,125 @@
+//  Copyright © 2009-2021 John Sheehan, Andrew Young, Alexey Zimarev and RestSharp community
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Adapted from Rebus
+
+using System.Collections.Concurrent;
+using System.Runtime.ExceptionServices;
+
+namespace RestSharp.Extensions {
+    public static class AsyncHelpers {
+        /// <summary>
+        /// Executes a task synchronously on the calling thread by installing a temporary synchronization context that queues continuations
+        /// </summary>
+        /// <param name="task">Callback for asynchronous task to run</param>
+        public static void RunSync(Func<Task> task) {
+            var currentContext = SynchronizationContext.Current;
+            var customContext  = new CustomSynchronizationContext(task);
+
+            try {
+                SynchronizationContext.SetSynchronizationContext(customContext);
+                customContext.Run();
+            }
+            finally {
+                SynchronizationContext.SetSynchronizationContext(currentContext);
+            }
+        }
+
+        /// <summary>
+        /// Executes a task synchronously on the calling thread by installing a temporary synchronization context that queues continuations
+        /// </summary>
+        /// <param name="task">Callback for asynchronous task to run</param>
+        /// <typeparam name="T">Return type for the task</typeparam>
+        /// <returns>Return value from the task</returns>
+        public static T RunSync<T>(Func<Task<T>> task) {
+            T result = default!;
+            RunSync(async () => { result = await task(); });
+            return result;
+        }
+
+        /// <summary>
+        /// Synchronization context that can be "pumped" in order to have it execute continuations posted back to it
+        /// </summary>
+        class CustomSynchronizationContext : SynchronizationContext {
+            readonly ConcurrentQueue<Tuple<SendOrPostCallback, object?>> _items            = new();
+            readonly AutoResetEvent                                      _workItemsWaiting = new(false);
+            readonly Func<Task>                                          _task;
+            ExceptionDispatchInfo?                                       _caughtException;
+            bool                                                         _done;
+
+            /// <summary>
+            /// Constructor for the custom context
+            /// </summary>
+            /// <param name="task">Task to execute</param>
+            public CustomSynchronizationContext(Func<Task> task) =>
+                _task = task ?? throw new ArgumentNullException(nameof(task), "Please remember to pass a Task to be executed");
+
+            /// <summary>
+            /// When overridden in a derived class, dispatches an asynchronous message to a synchronization context.
+            /// </summary>
+            /// <param name="function">Callback function</param>
+            /// <param name="state">Callback state</param>
+            public override void Post(SendOrPostCallback function, object? state) {
+                _items.Enqueue(Tuple.Create(function, state));
+                _workItemsWaiting.Set();
+            }
+
+            /// <summary>
+            /// Enqueues the function to be executed and executes all resulting continuations until it is completely done
+            /// </summary>
+            public void Run() {
+                async void PostCallback(object? _) {
+                    try {
+                        await _task().ConfigureAwait(false);
+                    }
+                    catch (Exception exception) {
+                        _caughtException = ExceptionDispatchInfo.Capture(exception);
+                        throw;
+                    }
+                    finally {
+                        Post(_ => _done = true, null);
+                    }
+                }
+
+                Post(PostCallback, null);
+
+                while (!_done) {
+                    if (_items.TryDequeue(out var task)) {
+                        task.Item1(task.Item2);
+                        if (_caughtException == null) {
+                            continue;
+                        }
+                        _caughtException.Throw();
+                    }
+                    else {
+                        _workItemsWaiting.WaitOne();
+                    }
+                }
+            }
+
+            /// <summary>
+            /// When overridden in a derived class, dispatches a synchronous message to a synchronization context.
+            /// </summary>
+            /// <param name="function">Callback function</param>
+            /// <param name="state">Callback state</param>
+            public override void Send(SendOrPostCallback function, object? state) => throw new NotSupportedException("Cannot send to same thread");
+
+            /// <summary>
+            /// When overridden in a derived class, creates a copy of the synchronization context. Not needed, so just return ourselves.
+            /// </summary>
+            /// <returns>Copy of the context</returns>
+            public override SynchronizationContext CreateCopy() => this;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/RestSharp/RestClient.Async.cs b/src/RestSharp/RestClient.Async.cs
index 3b162c42e..5b469b958 100644
--- a/src/RestSharp/RestClient.Async.cs
+++ b/src/RestSharp/RestClient.Async.cs
@@ -12,9 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+using RestSharp.Extensions;
+
 namespace RestSharp;
 
 public partial class RestClient {
+    /// <summary>
+    /// Executes the request synchronously, authenticating if needed
+    /// </summary>
+    /// <param name="request">Request to be executed</param>
+    public RestResponse Execute(RestRequest request) => AsyncHelpers.RunSync(() => ExecuteAsync(request));
+
     /// <summary>
     /// Executes the request asynchronously, authenticating if needed
     /// </summary>
@@ -85,6 +93,14 @@ async Task<InternalResponse> ExecuteInternal(RestRequest request, CancellationTo
 
     record InternalResponse(HttpResponseMessage? ResponseMessage, Uri Url, Exception? Exception, CancellationToken TimeoutToken);
 
+    /// <summary>
+    /// A specialized method to download files as streams.
+    /// </summary>
+    /// <param name="request">Pre-configured request instance.</param>
+    /// <returns>The downloaded stream.</returns>
+    [PublicAPI]
+    public Stream? DownloadStream(RestRequest request) => AsyncHelpers.RunSync(() => DownloadStreamAsync(request));
+
     /// <summary>
     /// A specialized method to download files as streams.
     /// </summary>
diff --git a/src/RestSharp/RestClientExtensions.Json.cs b/src/RestSharp/RestClientExtensions.Json.cs
index 6dd7b8dee..231dac19c 100644
--- a/src/RestSharp/RestClientExtensions.Json.cs
+++ b/src/RestSharp/RestClientExtensions.Json.cs
@@ -19,6 +19,18 @@
 namespace RestSharp;
 
 public static partial class RestClientExtensions {
+    /// <summary>
+    /// Calls the URL specified in the <code>resource</code> parameter, expecting a JSON response back. Deserializes and returns the response.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="resource">Resource URL</param>
+    /// <typeparam name="TResponse">Response object type</typeparam>
+    /// <returns>Deserialized response object</returns>
+    public static TResponse? GetJson<TResponse>(
+        this RestClient   client,
+        string            resource)
+        => AsyncHelpers.RunSync(() => client.GetJsonAsync<TResponse>(resource));
+
     /// <summary>
     /// Calls the URL specified in the <code>resource</code> parameter, expecting a JSON response back. Deserializes and returns the response.
     /// </summary>
@@ -32,6 +44,29 @@ public static partial class RestClientExtensions {
         return client.GetAsync<TResponse>(request, cancellationToken);
     }
 
+    /// <summary>
+    /// Calls the URL specified in the <code>resource</code> parameter, expecting a JSON response back. Deserializes and returns the response.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="resource">Resource URL</param>
+    /// <param name="parameters">Parameters to pass to the request</param>
+    /// <typeparam name="TResponse">Response object type</typeparam>
+    /// <returns>Deserialized response object</returns>
+    public static TResponse? GetJson<TResponse>(
+        this RestClient   client,
+        string            resource,
+        object            parameters)
+        => AsyncHelpers.RunSync(() => client.GetJsonAsync<TResponse>(resource, parameters));
+
+    /// <summary>
+    /// Calls the URL specified in the <code>resource</code> parameter, expecting a JSON response back. Deserializes and returns the response.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="resource">Resource URL</param>
+    /// <param name="parameters">Parameters to pass to the request</param>
+    /// <param name="cancellationToken">Cancellation token</param>
+    /// <typeparam name="TResponse">Response object type</typeparam>
+    /// <returns>Deserialized response object</returns>
     public static Task<TResponse?> GetJsonAsync<TResponse>(
         this RestClient   client,
         string            resource,
@@ -49,6 +84,23 @@ public static partial class RestClientExtensions {
         return client.GetAsync<TResponse>(request, cancellationToken);
     }
 
+    /// <summary>
+    /// Serializes the <code>request</code> object to JSON and makes a POST call to the resource specified in the <code>resource</code> parameter.
+    /// Expects a JSON response back, deserializes it to <code>TResponse</code> type and returns it.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="resource">Resource URL</param>
+    /// <param name="request">Request object, must be serializable to JSON</param>
+    /// <typeparam name="TRequest">Request object type</typeparam>
+    /// <typeparam name="TResponse">Response object type</typeparam>
+    /// <returns>Deserialized response object</returns>
+    public static TResponse? PostJson<TRequest, TResponse>(
+        this RestClient   client,
+        string            resource,
+        TRequest          request
+    ) where TRequest : class
+        => AsyncHelpers.RunSync(() => client.PostJsonAsync<TRequest, TResponse>(resource, request));
+
     /// <summary>
     /// Serializes the <code>request</code> object to JSON and makes a POST call to the resource specified in the <code>resource</code> parameter.
     /// Expects a JSON response back, deserializes it to <code>TResponse</code> type and returns it.
@@ -70,6 +122,22 @@ public static partial class RestClientExtensions {
         return client.PostAsync<TResponse>(restRequest, cancellationToken);
     }
 
+    /// <summary>
+    /// Serializes the <code>request</code> object to JSON and makes a POST call to the resource specified in the <code>resource</code> parameter.
+    /// Expects no response back, just the status code.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="resource">Resource URL</param>
+    /// <param name="request">Request object, must be serializable to JSON</param>
+    /// <typeparam name="TRequest">Request object type</typeparam>
+    /// <returns>Response status code</returns>
+    public static HttpStatusCode PostJson<TRequest>(
+        this RestClient client,
+        string          resource,
+        TRequest        request
+    ) where TRequest : class
+        => AsyncHelpers.RunSync(() => client.PostJsonAsync(resource, request));
+
     /// <summary>
     /// Serializes the <code>request</code> object to JSON and makes a POST call to the resource specified in the <code>resource</code> parameter.
     /// Expects no response back, just the status code.
@@ -91,6 +159,23 @@ public static async Task<HttpStatusCode> PostJsonAsync<TRequest>(
         return response.StatusCode;
     }
 
+    /// <summary>
+    /// Serializes the <code>request</code> object to JSON and makes a PUT call to the resource specified in the <code>resource</code> parameter.
+    /// Expects a JSON response back, deserializes it to <code>TResponse</code> type and returns it.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="resource">Resource URL</param>
+    /// <param name="request">Request object, must be serializable to JSON</param>
+    /// <typeparam name="TRequest">Request object type</typeparam>
+    /// <typeparam name="TResponse">Response object type</typeparam>
+    /// <returns>Deserialized response object</returns>
+    public static TResponse? PutJson<TRequest, TResponse>(
+        this RestClient   client,
+        string            resource,
+        TRequest          request
+    ) where TRequest : class
+        => AsyncHelpers.RunSync(() => client.PutJsonAsync<TRequest, TResponse>(resource, request));
+
     /// <summary>
     /// Serializes the <code>request</code> object to JSON and makes a PUT call to the resource specified in the <code>resource</code> parameter.
     /// Expects a JSON response back, deserializes it to <code>TResponse</code> type and returns it.
@@ -112,6 +197,22 @@ public static async Task<HttpStatusCode> PostJsonAsync<TRequest>(
         return client.PutAsync<TResponse>(restRequest, cancellationToken);
     }
 
+    /// <summary>
+    /// Serializes the <code>request</code> object to JSON and makes a PUT call to the resource specified in the <code>resource</code> parameter.
+    /// Expects no response back, just the status code.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="resource">Resource URL</param>
+    /// <param name="request">Request object, must be serializable to JSON</param>
+    /// <typeparam name="TRequest">Request object type</typeparam>
+    /// <returns>Response status code</returns>
+    public static HttpStatusCode PutJson<TRequest>(
+        this RestClient client,
+        string          resource,
+        TRequest        request
+    ) where TRequest : class
+        => AsyncHelpers.RunSync(() => client.PutJsonAsync(resource, request));
+
     /// <summary>
     /// Serializes the <code>request</code> object to JSON and makes a PUT call to the resource specified in the <code>resource</code> parameter.
     /// Expects no response back, just the status code.
diff --git a/src/RestSharp/RestClientExtensions.cs b/src/RestSharp/RestClientExtensions.cs
index db38adc08..27410fb35 100644
--- a/src/RestSharp/RestClientExtensions.cs
+++ b/src/RestSharp/RestClientExtensions.cs
@@ -19,6 +19,17 @@ namespace RestSharp;
 
 [PublicAPI]
 public static partial class RestClientExtensions {
+    /// <summary>
+    /// Executes a GET-style request synchronously, authenticating if needed.
+    /// The response content then gets deserialized to T.
+    /// </summary>
+    /// <typeparam name="T">Target deserialization type</typeparam>
+    /// <param name="client"></param>
+    /// <param name="request">Request to be executed</param>
+    /// <returns>Deserialized response content</returns>
+    public static RestResponse<T> ExecuteGet<T>(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.ExecuteAsync<T>(request, Method.Get));
+
     /// <summary>
     /// Executes a GET-style request asynchronously, authenticating if needed.
     /// The response content then gets deserialized to T.
@@ -31,6 +42,14 @@ public static partial class RestClientExtensions {
     public static Task<RestResponse<T>> ExecuteGetAsync<T>(this RestClient client, RestRequest request, CancellationToken cancellationToken = default)
         => client.ExecuteAsync<T>(request, Method.Get, cancellationToken);
 
+    /// <summary>
+    /// Executes a GET-style synchronously, authenticating if needed
+    /// </summary>
+    /// <param name="client"></param>
+    /// <param name="request">Request to be executed</param>
+    public static RestResponse ExecuteGet(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.ExecuteAsync(request, Method.Get));
+
     /// <summary>
     /// Executes a GET-style asynchronously, authenticating if needed
     /// </summary>
@@ -40,6 +59,20 @@ public static Task<RestResponse<T>> ExecuteGetAsync<T>(this RestClient client, R
     public static Task<RestResponse> ExecuteGetAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default)
         => client.ExecuteAsync(request, Method.Get, cancellationToken);
 
+    /// <summary>
+    /// Executes a POST-style request synchronously, authenticating if needed.
+    /// The response content then gets deserialized to T.
+    /// </summary>
+    /// <typeparam name="T">Target deserialization type</typeparam>
+    /// <param name="client"></param>
+    /// <param name="request">Request to be executed</param>
+    /// <returns>Deserialized response content</returns>
+    public static RestResponse<T> ExecutePost<T>(
+        this RestClient   client,
+        RestRequest       request
+    )
+        => AsyncHelpers.RunSync(() => client.ExecuteAsync<T>(request, Method.Post));
+
     /// <summary>
     /// Executes a POST-style request asynchronously, authenticating if needed.
     /// The response content then gets deserialized to T.
@@ -56,6 +89,14 @@ public static Task<RestResponse<T>> ExecutePostAsync<T>(
     )
         => client.ExecuteAsync<T>(request, Method.Post, cancellationToken);
 
+    /// <summary>
+    /// Executes a POST-style synchronously, authenticating if needed
+    /// </summary>
+    /// <param name="client"></param>
+    /// <param name="request">Request to be executed</param>
+    public static RestResponse ExecutePost(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.ExecuteAsync(request, Method.Post));
+
     /// <summary>
     /// Executes a POST-style asynchronously, authenticating if needed
     /// </summary>
@@ -65,6 +106,20 @@ public static Task<RestResponse<T>> ExecutePostAsync<T>(
     public static Task<RestResponse> ExecutePostAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default)
         => client.ExecuteAsync(request, Method.Post, cancellationToken);
 
+    /// <summary>
+    /// Executes a PUT-style request synchronously, authenticating if needed.
+    /// The response content then gets deserialized to T.
+    /// </summary>
+    /// <typeparam name="T">Target deserialization type</typeparam>
+    /// <param name="client"></param>
+    /// <param name="request">Request to be executed</param>
+    /// <returns>Deserialized response content</returns>
+    public static RestResponse<T> ExecutePut<T>(
+        this RestClient   client,
+        RestRequest       request
+    )
+        => AsyncHelpers.RunSync(() => client.ExecuteAsync<T>(request, Method.Put));
+
     /// <summary>
     /// Executes a PUT-style request asynchronously, authenticating if needed.
     /// The response content then gets deserialized to T.
@@ -81,6 +136,14 @@ public static Task<RestResponse<T>> ExecutePutAsync<T>(
     )
         => client.ExecuteAsync<T>(request, Method.Put, cancellationToken);
 
+    /// <summary>
+    /// Executes a PUP-style synchronously, authenticating if needed
+    /// </summary>
+    /// <param name="client"></param>
+    /// <param name="request">Request to be executed</param>
+    public static RestResponse ExecutePut(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.ExecuteAsync(request, Method.Put));
+
     /// <summary>
     /// Executes a PUP-style asynchronously, authenticating if needed
     /// </summary>
@@ -90,6 +153,18 @@ public static Task<RestResponse<T>> ExecutePutAsync<T>(
     public static Task<RestResponse> ExecutePutAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default)
         => client.ExecuteAsync(request, Method.Put, cancellationToken);
 
+    /// <summary>
+    /// Executes the request synchronously, authenticating if needed
+    /// </summary>
+    /// <typeparam name="T">Target deserialization type</typeparam>
+    /// <param name="client"></param>
+    /// <param name="request">Request to be executed</param>
+    public static RestResponse<T> Execute<T>(
+        this RestClient client,
+        RestRequest     request
+    )
+        => AsyncHelpers.RunSync(() => client.ExecuteAsync<T>(request));
+
     /// <summary>
     /// Executes the request asynchronously, authenticating if needed
     /// </summary>
@@ -109,6 +184,19 @@ public static async Task<RestResponse<T>> ExecuteAsync<T>(
         return client.Deserialize<T>(request, response);
     }
 
+    /// <summary>
+    /// Executes the request synchronously, authenticating if needed
+    /// </summary>
+    /// <param name="client"></param>
+    /// <param name="request">Request to be executed</param>
+    /// <param name="httpMethod">Override the request method</param>
+    public static RestResponse Execute(
+        this RestClient   client,
+        RestRequest       request,
+        Method            httpMethod
+    )
+        => AsyncHelpers.RunSync(() => client.ExecuteAsync(request, httpMethod));
+
     /// <summary>
     /// Executes the request asynchronously, authenticating if needed
     /// </summary>
@@ -128,6 +216,20 @@ public static Task<RestResponse> ExecuteAsync(
         return client.ExecuteAsync(request, cancellationToken);
     }
 
+    /// <summary>
+    /// Executes the request synchronously, authenticating if needed
+    /// </summary>
+    /// <typeparam name="T">Target deserialization type</typeparam>
+    /// <param name="client"></param>
+    /// <param name="request">Request to be executed</param>
+    /// <param name="httpMethod">Override the request method</param>
+    public static RestResponse<T> Execute<T>(
+        this RestClient   client,
+        RestRequest       request,
+        Method            httpMethod
+    )
+        => AsyncHelpers.RunSync(() => client.ExecuteAsync<T>(request, httpMethod));
+
     /// <summary>
     /// Executes the request asynchronously, authenticating if needed
     /// </summary>
@@ -148,6 +250,17 @@ public static Task<RestResponse<T>> ExecuteAsync<T>(
         return client.ExecuteAsync<T>(request, cancellationToken);
     }
 
+    /// <summary>
+    /// Execute the request using GET HTTP method. Exception will be thrown if the request does not succeed.
+    /// The response data is deserialized to the Data property of the returned response object.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="request">The request</param>
+    /// <typeparam name="T">Expected result type</typeparam>
+    /// <returns></returns>
+    public static T? Get<T>(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.GetAsync<T>(request));
+
     /// <summary>
     /// Execute the request using GET HTTP method. Exception will be thrown if the request does not succeed.
     /// The response data is deserialized to the Data property of the returned response object.
@@ -163,12 +276,26 @@ public static Task<RestResponse<T>> ExecuteAsync<T>(
         return response.Data;
     }
 
+    public static RestResponse Get(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.GetAsync(request));
+
     public static async Task<RestResponse> GetAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteGetAsync(request, cancellationToken).ConfigureAwait(false);
         RestClient.ThrowIfError(response);
         return response;
     }
 
+    /// <summary>
+    /// Execute the request using POST HTTP method. Exception will be thrown if the request does not succeed.
+    /// The response data is deserialized to the Data property of the returned response object.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="request">The request</param>
+    /// <typeparam name="T">Expected result type</typeparam>
+    /// <returns></returns>
+    public static T? Post<T>(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.PostAsync<T>(request));
+
     /// <summary>
     /// Execute the request using POST HTTP method. Exception will be thrown if the request does not succeed.
     /// The response data is deserialized to the Data property of the returned response object.
@@ -184,12 +311,26 @@ public static async Task<RestResponse> GetAsync(this RestClient client, RestRequ
         return response.Data;
     }
 
+    public static RestResponse Post(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.PostAsync(request));
+
     public static async Task<RestResponse> PostAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecutePostAsync(request, cancellationToken).ConfigureAwait(false);
         RestClient.ThrowIfError(response);
         return response;
     }
 
+    /// <summary>
+    /// Execute the request using PUT HTTP method. Exception will be thrown if the request does not succeed.
+    /// The response data is deserialized to the Data property of the returned response object.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="request">The request</param>
+    /// <typeparam name="T">Expected result type</typeparam>
+    /// <returns></returns>
+    public static T? Put<T>(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.PutAsync<T>(request));
+
     /// <summary>
     /// Execute the request using PUT HTTP method. Exception will be thrown if the request does not succeed.
     /// The response data is deserialized to the Data property of the returned response object.
@@ -205,12 +346,26 @@ public static async Task<RestResponse> PostAsync(this RestClient client, RestReq
         return response.Data;
     }
 
+    public static RestResponse Put(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.PutAsync(request));
+
     public static async Task<RestResponse> PutAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Put, cancellationToken).ConfigureAwait(false);
         RestClient.ThrowIfError(response);
         return response;
     }
 
+    /// <summary>
+    /// Execute the request using HEAD HTTP method. Exception will be thrown if the request does not succeed.
+    /// The response data is deserialized to the Data property of the returned response object.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="request">The request</param>
+    /// <typeparam name="T">Expected result type</typeparam>
+    /// <returns></returns>
+    public static T? Head<T>(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.HeadAsync<T>(request));
+
     /// <summary>
     /// Execute the request using HEAD HTTP method. Exception will be thrown if the request does not succeed.
     /// The response data is deserialized to the Data property of the returned response object.
@@ -226,12 +381,26 @@ public static async Task<RestResponse> PutAsync(this RestClient client, RestRequ
         return response.Data;
     }
 
+    public static RestResponse Head(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.HeadAsync(request));
+
     public static async Task<RestResponse> HeadAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Head, cancellationToken).ConfigureAwait(false);
         RestClient.ThrowIfError(response);
         return response;
     }
 
+    /// <summary>
+    /// Execute the request using OPTIONS HTTP method. Exception will be thrown if the request does not succeed.
+    /// The response data is deserialized to the Data property of the returned response object.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="request">The request</param>
+    /// <typeparam name="T">Expected result type</typeparam>
+    /// <returns></returns>
+    public static T? Options<T>(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.OptionsAsync<T>(request));
+
     /// <summary>
     /// Execute the request using OPTIONS HTTP method. Exception will be thrown if the request does not succeed.
     /// The response data is deserialized to the Data property of the returned response object.
@@ -247,12 +416,26 @@ public static async Task<RestResponse> HeadAsync(this RestClient client, RestReq
         return response.Data;
     }
 
+    public static RestResponse Options(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.OptionsAsync(request));
+
     public static async Task<RestResponse> OptionsAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Options, cancellationToken).ConfigureAwait(false);
         RestClient.ThrowIfError(response);
         return response;
     }
 
+    /// <summary>
+    /// Execute the request using PATCH HTTP method. Exception will be thrown if the request does not succeed.
+    /// The response data is deserialized to the Data property of the returned response object.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="request">The request</param>
+    /// <typeparam name="T">Expected result type</typeparam>
+    /// <returns></returns>
+    public static T? Patch<T>(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.PatchAsync<T>(request));
+
     /// <summary>
     /// Execute the request using PATCH HTTP method. Exception will be thrown if the request does not succeed.
     /// The response data is deserialized to the Data property of the returned response object.
@@ -268,12 +451,26 @@ public static async Task<RestResponse> OptionsAsync(this RestClient client, Rest
         return response.Data;
     }
 
+    public static RestResponse Patch(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.PatchAsync(request));
+
     public static async Task<RestResponse> PatchAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Patch, cancellationToken).ConfigureAwait(false);
         RestClient.ThrowIfError(response);
         return response;
     }
 
+    /// <summary>
+    /// Execute the request using DELETE HTTP method. Exception will be thrown if the request does not succeed.
+    /// The response data is deserialized to the Data property of the returned response object.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="request">The request</param>
+    /// <typeparam name="T">Expected result type</typeparam>
+    /// <returns></returns>
+    public static T? Delete<T>(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.DeleteAsync<T>(request));
+
     /// <summary>
     /// Execute the request using DELETE HTTP method. Exception will be thrown if the request does not succeed.
     /// The response data is deserialized to the Data property of the returned response object.
@@ -289,12 +486,25 @@ public static async Task<RestResponse> PatchAsync(this RestClient client, RestRe
         return response.Data;
     }
 
+    public static RestResponse Delete(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.DeleteAsync(request));
+
     public static async Task<RestResponse> DeleteAsync(this RestClient client, RestRequest request, CancellationToken cancellationToken = default) {
         var response = await client.ExecuteAsync(request, Method.Delete, cancellationToken).ConfigureAwait(false);
         RestClient.ThrowIfError(response);
         return response;
     }
 
+    /// <summary>
+    /// A specialized method to download files.
+    /// </summary>
+    /// <param name="client">RestClient instance</param>
+    /// <param name="request">Pre-configured request instance.</param>
+    /// <returns>The downloaded file.</returns>
+    [PublicAPI]
+    public static byte[]? DownloadData(this RestClient client, RestRequest request)
+        => AsyncHelpers.RunSync(() => client.DownloadDataAsync(request));
+
     /// <summary>
     /// A specialized method to download files.
     /// </summary>