@seamapi/nextlove-sdk-generator 1.4.0

package/src/lib/generate-csharp-sdk/templates/fs/src/Seam/Client/Seam.cs

@@ -0,0 +1,1070 @@
+/*
+ * Seam Connect
+ *
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Generated by: https://github.com/openapitools/openapi-generator.git
+ */
+
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Formatters;
+using System.Text;
+using System.Threading;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using System.Web;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using RestSharp;
+using RestSharp.Serializers;
+using RestSharpMethod = RestSharp.Method;
+using Polly;
+using Seam.Model;
+
+namespace Seam.Client
+{
+    /// <summary>
+    /// Allows RestSharp to Serialize/Deserialize JSON using our custom logic, but only when ContentType is JSON.
+    /// </summary>
+    internal class CustomJsonCodec : IRestSerializer, ISerializer, IDeserializer
+    {
+        private readonly IReadableSeamRequestConfiguration _configuration;
+        private readonly JsonSerializerSettings _serializerSettings = new JsonSerializerSettings
+        {
+            // OpenAPI generated types generally hide default constructors.
+            ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
+            ContractResolver = new DefaultContractResolver
+            {
+                NamingStrategy = new CamelCaseNamingStrategy { OverrideSpecifiedNames = false }
+            }
+        };
+
+        public CustomJsonCodec(IReadableSeamRequestConfiguration configuration)
+        {
+            _configuration = configuration;
+        }
+
+        public CustomJsonCodec(
+            JsonSerializerSettings serializerSettings,
+            IReadableSeamRequestConfiguration configuration
+        )
+        {
+            _serializerSettings = serializerSettings;
+            _configuration = configuration;
+        }
+
+        /// <summary>
+        /// Serialize the object into a JSON string.
+        /// </summary>
+        /// <param name="obj">Object to be serialized.</param>
+        /// <returns>A JSON string.</returns>
+        public string Serialize(object obj)
+        {
+            return JsonConvert.SerializeObject(obj, _serializerSettings);
+        }
+
+        public string Serialize(Parameter bodyParameter) => Serialize(bodyParameter.Value);
+
+        public T Deserialize<T>(RestResponse response)
+        {
+            var result = (T)Deserialize(response, typeof(T));
+            return result;
+        }
+
+        /// <summary>
+        /// Deserialize the JSON string into a proper object.
+        /// </summary>
+        /// <param name="response">The HTTP response.</param>
+        /// <param name="type">Object type.</param>
+        /// <returns>Object representation of the JSON string.</returns>
+        internal object Deserialize(RestResponse response, Type type)
+        {
+            if (type == typeof(byte[])) // return byte array
+            {
+                return response.RawBytes;
+            }
+
+            // TODO: ? if (type.IsAssignableFrom(typeof(Stream)))
+            if (type == typeof(Stream))
+            {
+                var bytes = response.RawBytes;
+                if (response.Headers != null)
+                {
+                    var filePath = string.IsNullOrEmpty(_configuration.TempFolderPath)
+                        ? Path.GetTempPath()
+                        : _configuration.TempFolderPath;
+                    var regex = new Regex(
+                        @"Content-Disposition=.*filename=['""]?([^'""\s]+)['""]?$"
+                    );
+                    foreach (var header in response.Headers)
+                    {
+                        var match = regex.Match(header.ToString());
+                        if (match.Success)
+                        {
+                            string fileName =
+                                filePath
+                                + ClientUtils.SanitizeFilename(
+                                    match.Groups[1].Value.Replace("\"", "").Replace("'", "")
+                                );
+                            File.WriteAllBytes(fileName, bytes);
+                            return new FileStream(fileName, FileMode.Open);
+                        }
+                    }
+                }
+                var stream = new MemoryStream(bytes);
+                return stream;
+            }
+
+            if (type.Name.StartsWith("System.Nullable`1[[System.DateTime")) // return a datetime object
+            {
+                return DateTime.Parse(
+                    response.Content,
+                    null,
+                    System.Globalization.DateTimeStyles.RoundtripKind
+                );
+            }
+
+            if (type == typeof(string) || type.Name.StartsWith("System.Nullable")) // return primitive type
+            {
+                return Convert.ChangeType(response.Content, type);
+            }
+
+            // at this point, it must be a model (json)
+            try
+            {
+                return JsonConvert.DeserializeObject(response.Content, type, _serializerSettings);
+            }
+            catch (Exception e)
+            {
+                throw new SeamException(500, e.Message, response.Content);
+            }
+        }
+
+        public ISerializer Serializer => this;
+        public IDeserializer Deserializer => this;
+
+        public string[] AcceptedContentTypes => RestSharp.ContentType.JsonAccept;
+
+        public SupportsContentType SupportsContentType =>
+            contentType =>
+                contentType.Value.EndsWith("json", StringComparison.InvariantCultureIgnoreCase)
+                || contentType.Value.EndsWith(
+                    "javascript",
+                    StringComparison.InvariantCultureIgnoreCase
+                );
+
+        public ContentType ContentType { get; set; } = RestSharp.ContentType.Json;
+
+        public DataFormat DataFormat => DataFormat.Json;
+    }
+
+    public partial interface ISeamClient : ISynchronousSeam, IAsynchronousSeam, IDisposable { }
+
+    /// <summary>
+    /// Provides a default implementation of an Api client (both synchronous and asynchronous implementations),
+    /// encapsulating general REST accessor use cases.
+    /// </summary>
+    public partial class SeamClient : ISeamClient
+    {
+        private readonly string _baseUrl;
+        private readonly string _apiToken;
+
+        /// <summary>
+        /// Specifies the settings on a <see cref="JsonSerializer" /> object.
+        /// These settings can be adjusted to accommodate custom serialization rules.
+        /// </summary>
+        public JsonSerializerSettings SerializerSettings { get; set; } =
+            new JsonSerializerSettings
+            {
+                // OpenAPI generated types generally hide default constructors.
+                ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor,
+                ContractResolver = new DefaultContractResolver
+                {
+                    NamingStrategy = new CamelCaseNamingStrategy { OverrideSpecifiedNames = false }
+                }
+            };
+
+        /// <summary>
+        /// Allows for extending request processing for <see cref="ApiClient"/> generated code.
+        /// </summary>
+        /// <param name="request">The RestSharp request object</param>
+        partial void InterceptRequest(RestRequest request);
+
+        /// <summary>
+        /// Allows for extending response processing for <see cref="ApiClient"/> generated code.
+        /// </summary>
+        /// <param name="request">The RestSharp request object</param>
+        /// <param name="response">The RestSharp response object</param>
+        partial void InterceptResponse(RestRequest request, RestResponse response);
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ApiClient" />
+        /// </summary>
+        /// <param name="basePath">The target service's base path in URL format.</param>
+        /// <param name="apiToken">The target service's API Token.</param>
+        /// <exception cref="ArgumentException"></exception>
+        public SeamClient(string apiToken)
+            : this(GlobalSeamRequestConfiguration.Instance.BasePath, apiToken) { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ApiClient" />
+        /// </summary>
+        /// <param name="basePath">The target service's base path in URL format.</param>
+        /// <param name="apiToken">The target service's API Token.</param>
+        /// <exception cref="ArgumentException"></exception>
+        public SeamClient(string basePath, string apiToken)
+        {
+            if (string.IsNullOrEmpty(basePath))
+                throw new ArgumentException("basePath cannot be empty");
+
+            if (string.IsNullOrEmpty(apiToken))
+                throw new ArgumentException("apiToken cannot be empty");
+
+            _baseUrl = basePath;
+            _apiToken = apiToken;
+        }
+
+        /// <summary>
+        /// Constructs the RestSharp version of an http method
+        /// </summary>
+        /// <param name="method">Swagger Client Custom HttpMethod</param>
+        /// <returns>RestSharp's HttpMethod instance.</returns>
+        /// <exception cref="ArgumentOutOfRangeException"></exception>
+        private RestSharpMethod Method(HttpMethod method)
+        {
+            RestSharpMethod other;
+            switch (method)
+            {
+                case HttpMethod.Get:
+                    other = RestSharpMethod.Get;
+                    break;
+                case HttpMethod.Post:
+                    other = RestSharpMethod.Post;
+                    break;
+                case HttpMethod.Put:
+                    other = RestSharpMethod.Put;
+                    break;
+                case HttpMethod.Delete:
+                    other = RestSharpMethod.Delete;
+                    break;
+                case HttpMethod.Head:
+                    other = RestSharpMethod.Head;
+                    break;
+                case HttpMethod.Options:
+                    other = RestSharpMethod.Options;
+                    break;
+                case HttpMethod.Patch:
+                    other = RestSharpMethod.Patch;
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException("method", method, null);
+            }
+
+            return other;
+        }
+
+        /// <summary>
+        /// Provides all logic for constructing a new RestSharp <see cref="RestRequest"/>.
+        /// At this point, all information for querying the service is known. Here, it is simply
+        /// mapped into the RestSharp request.
+        /// </summary>
+        /// <param name="method">The http verb.</param>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <returns>[private] A new RestRequest instance.</returns>
+        /// <exception cref="ArgumentNullException"></exception>
+        private RestRequest NewRequest(
+            HttpMethod method,
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null,
+            string apiToken = null
+        )
+        {
+            if (path == null)
+                throw new ArgumentNullException("path");
+            if (options == null)
+                throw new ArgumentNullException("options");
+            if (configuration == null)
+                throw new ArgumentNullException("configuration");
+
+            apiToken ??= _apiToken;
+
+            RestRequest request = new RestRequest(path, Method(method));
+
+            if (options.PathParameters != null)
+            {
+                foreach (var pathParam in options.PathParameters)
+                {
+                    request.AddParameter(pathParam.Key, pathParam.Value, ParameterType.UrlSegment);
+                }
+            }
+
+            if (options.QueryParameters != null)
+            {
+                foreach (var queryParam in options.QueryParameters)
+                {
+                    foreach (var value in queryParam.Value)
+                    {
+                        request.AddQueryParameter(queryParam.Key, value);
+                    }
+                }
+            }
+
+            if (configuration.DefaultHeaders != null)
+            {
+                foreach (var headerParam in configuration.DefaultHeaders)
+                {
+                    request.AddHeader(headerParam.Key, headerParam.Value);
+                }
+            }
+
+            if (apiToken != null)
+            {
+                request.AddHeader("Authorization", "Bearer " + apiToken);
+            }
+
+            if (options.HeaderParameters != null)
+            {
+                foreach (var headerParam in options.HeaderParameters)
+                {
+                    foreach (var value in headerParam.Value)
+                    {
+                        request.AddHeader(headerParam.Key, value);
+                    }
+                }
+            }
+
+            if (options.FormParameters != null)
+            {
+                foreach (var formParam in options.FormParameters)
+                {
+                    request.AddParameter(formParam.Key, formParam.Value);
+                }
+            }
+
+            if (options.Data != null)
+            {
+                if (options.Data is Stream stream)
+                {
+                    var contentType = "application/octet-stream";
+                    if (options.HeaderParameters != null)
+                    {
+                        var contentTypes = options.HeaderParameters["Content-Type"];
+                        contentType = contentTypes[0];
+                    }
+
+                    var bytes = ClientUtils.ReadAsBytes(stream);
+                    request.AddParameter(contentType, bytes, ParameterType.RequestBody);
+                }
+                else
+                {
+                    if (options.HeaderParameters != null)
+                    {
+                        IList<string> contentTypes = null;
+
+                        if (options.HeaderParameters.ContainsKey("Content-Type"))
+                        {
+                            contentTypes = options.HeaderParameters["Content-Type"];
+                        }
+
+                        if (
+                            contentTypes == null
+                            || contentTypes.Any(header => header.Contains("application/json"))
+                        )
+                        {
+                            request.RequestFormat = DataFormat.Json;
+                        }
+                        else
+                        {
+                            // TODO: Generated client user should add additional handlers. RestSharp only supports XML and JSON, with XML as default.
+                        }
+                    }
+                    else
+                    {
+                        // Here, we'll assume JSON APIs are more common. XML can be forced by adding produces/consumes to openapi spec explicitly.
+                        request.RequestFormat = DataFormat.Json;
+                    }
+
+                    request.AddJsonBody(options.Data);
+                }
+            }
+
+            if (options.FileParameters != null)
+            {
+                foreach (var fileParam in options.FileParameters)
+                {
+                    foreach (var file in fileParam.Value)
+                    {
+                        var bytes = ClientUtils.ReadAsBytes(file);
+                        var fileStream = file as FileStream;
+                        if (fileStream != null)
+                            request.AddFile(
+                                fileParam.Key,
+                                bytes,
+                                System.IO.Path.GetFileName(fileStream.Name)
+                            );
+                        else
+                            request.AddFile(fileParam.Key, bytes, "no_file_name_provided");
+                    }
+                }
+            }
+
+            return request;
+        }
+
+        private ApiResponse<T> ToApiResponse<T>(RestResponse<T> response)
+        {
+            T result = response.Data;
+            string rawContent = response.Content;
+
+            var transformed = new ApiResponse<T>(
+                response.StatusCode,
+                new Multimap<string, string>(),
+                result,
+                rawContent
+            )
+            {
+                ErrorText = response.ErrorMessage,
+                Cookies = new List<Cookie>()
+            };
+
+            if (response.Headers != null)
+            {
+                foreach (var responseHeader in response.Headers)
+                {
+                    transformed.Headers.Add(
+                        responseHeader.Name,
+                        ClientUtils.ParameterToString(responseHeader.Value)
+                    );
+                }
+            }
+
+            if (response.ContentHeaders != null)
+            {
+                foreach (var responseHeader in response.ContentHeaders)
+                {
+                    transformed.Headers.Add(
+                        responseHeader.Name,
+                        ClientUtils.ParameterToString(responseHeader.Value)
+                    );
+                }
+            }
+
+            if (response.Cookies != null)
+            {
+                foreach (var responseCookies in response.Cookies.Cast<Cookie>())
+                {
+                    transformed.Cookies.Add(
+                        new Cookie(
+                            responseCookies.Name,
+                            responseCookies.Value,
+                            responseCookies.Path,
+                            responseCookies.Domain
+                        )
+                    );
+                }
+            }
+
+            return transformed;
+        }
+
+        private ApiResponse<T> Exec<T>(
+            RestRequest request,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration
+        )
+        {
+            var baseUrl = _baseUrl;
+
+            var cookies = new CookieContainer();
+
+            if (options.Cookies != null && options.Cookies.Count > 0)
+            {
+                foreach (var cookie in options.Cookies)
+                {
+                    cookies.Add(new Cookie(cookie.Name, cookie.Value));
+                }
+            }
+
+            var clientOptions = new RestClientOptions(baseUrl)
+            {
+                ClientCertificates = configuration.ClientCertificates,
+                CookieContainer = cookies,
+                MaxTimeout = configuration.Timeout,
+                Proxy = configuration.Proxy,
+                UserAgent = configuration.UserAgent,
+                // UseDefaultCredentials = configuration.UseDefaultCredentials,
+                RemoteCertificateValidationCallback =
+                    configuration.RemoteCertificateValidationCallback,
+                ThrowOnAnyError = false
+            };
+
+            using (
+                RestClient client = new RestClient(
+                    clientOptions,
+                    configureSerialization: serializerConfig =>
+                        serializerConfig.UseSerializer(
+                            () => new CustomJsonCodec(SerializerSettings, configuration)
+                        )
+                )
+            )
+            {
+                InterceptRequest(request);
+
+                RestResponse<T> response;
+                if (RetryConfiguration.RetryPolicy != null)
+                {
+                    var policy = RetryConfiguration.RetryPolicy;
+                    var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
+                    response =
+                        (policyResult.Outcome == OutcomeType.Successful)
+                            ? client.Deserialize<T>(policyResult.Result)
+                            : new RestResponse<T>(request)
+                            {
+                                ErrorException = policyResult.FinalException
+                            };
+                }
+                else
+                {
+                    response = client.Execute<T>(request);
+                }
+
+                // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
+                if (typeof(AbstractModelSchema).IsAssignableFrom(typeof(T)))
+                {
+                    try
+                    {
+                        response.Data = (T)
+                            typeof(T)
+                                .GetMethod("FromJson")
+                                .Invoke(null, new object[] { response.Content });
+                    }
+                    catch (Exception ex)
+                    {
+                        throw ex.InnerException != null ? ex.InnerException : ex;
+                    }
+                }
+                else if (typeof(T).Name == "Stream") // for binary response
+                {
+                    response.Data = (T)(object)new MemoryStream(response.RawBytes);
+                }
+                else if (typeof(T).Name == "Byte[]") // for byte response
+                {
+                    response.Data = (T)(object)response.RawBytes;
+                }
+                else if (typeof(T).Name == "String") // for string response
+                {
+                    response.Data = (T)(object)response.Content;
+                }
+
+                InterceptResponse(request, response);
+
+                var result = ToApiResponse(response);
+                if (response.ErrorMessage != null)
+                {
+                    result.ErrorText = response.ErrorMessage;
+                }
+
+                if (response.Cookies != null && response.Cookies.Count > 0)
+                {
+                    if (result.Cookies == null)
+                        result.Cookies = new List<Cookie>();
+                    foreach (var restResponseCookie in response.Cookies.Cast<Cookie>())
+                    {
+                        var cookie = new Cookie(
+                            restResponseCookie.Name,
+                            restResponseCookie.Value,
+                            restResponseCookie.Path,
+                            restResponseCookie.Domain
+                        )
+                        {
+                            Comment = restResponseCookie.Comment,
+                            CommentUri = restResponseCookie.CommentUri,
+                            Discard = restResponseCookie.Discard,
+                            Expired = restResponseCookie.Expired,
+                            Expires = restResponseCookie.Expires,
+                            HttpOnly = restResponseCookie.HttpOnly,
+                            Port = restResponseCookie.Port,
+                            Secure = restResponseCookie.Secure,
+                            Version = restResponseCookie.Version
+                        };
+
+                        result.Cookies.Add(cookie);
+                    }
+                }
+
+                var exceptionFactory = SeamRequestConfiguration.DefaultExceptionFactory;
+                if (exceptionFactory != null)
+                {
+                    var exception = exceptionFactory(request.Resource, result);
+                    if (exception != null)
+                    {
+                        throw exception;
+                    }
+                }
+
+                return result;
+            }
+        }
+
+        private async Task<ApiResponse<T>> ExecAsync<T>(
+            RestRequest request,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration,
+            System.Threading.CancellationToken cancellationToken =
+                default(System.Threading.CancellationToken)
+        )
+        {
+            var baseUrl = _baseUrl;
+
+            var clientOptions = new RestClientOptions(baseUrl)
+            {
+                ClientCertificates = configuration.ClientCertificates,
+                MaxTimeout = configuration.Timeout,
+                Proxy = configuration.Proxy,
+                UserAgent = configuration.UserAgent,
+                ThrowOnAnyError = false
+            };
+
+            using (
+                RestClient client = new RestClient(
+                    clientOptions,
+                    configureSerialization: serializerConfig =>
+                        serializerConfig.UseSerializer(
+                            () => new CustomJsonCodec(SerializerSettings, configuration)
+                        )
+                )
+            )
+            {
+                InterceptRequest(request);
+
+                RestResponse<T> response;
+                if (RetryConfiguration.AsyncRetryPolicy != null)
+                {
+                    var policy = RetryConfiguration.AsyncRetryPolicy;
+                    var policyResult = await policy
+                        .ExecuteAndCaptureAsync(
+                            (ct) => client.ExecuteAsync(request, ct),
+                            cancellationToken
+                        )
+                        .ConfigureAwait(false);
+                    response =
+                        (policyResult.Outcome == OutcomeType.Successful)
+                            ? client.Deserialize<T>(policyResult.Result)
+                            : new RestResponse<T>(request)
+                            {
+                                ErrorException = policyResult.FinalException
+                            };
+                }
+                else
+                {
+                    response = await client
+                        .ExecuteAsync<T>(request, cancellationToken)
+                        .ConfigureAwait(false);
+                }
+
+                // if the response type is oneOf/anyOf, call FromJSON to deserialize the data
+                if (typeof(AbstractModelSchema).IsAssignableFrom(typeof(T)))
+                {
+                    response.Data = (T)
+                        typeof(T)
+                            .GetMethod("FromJson")
+                            .Invoke(null, new object[] { response.Content });
+                }
+                else if (typeof(T).Name == "Stream") // for binary response
+                {
+                    response.Data = (T)(object)new MemoryStream(response.RawBytes);
+                }
+                else if (typeof(T).Name == "Byte[]") // for byte response
+                {
+                    response.Data = (T)(object)response.RawBytes;
+                }
+
+                InterceptResponse(request, response);
+
+                var result = ToApiResponse(response);
+                if (response.ErrorMessage != null)
+                {
+                    result.ErrorText = response.ErrorMessage;
+                }
+
+                if (response.Cookies != null && response.Cookies.Count > 0)
+                {
+                    if (result.Cookies == null)
+                        result.Cookies = new List<Cookie>();
+                    foreach (var restResponseCookie in response.Cookies.Cast<Cookie>())
+                    {
+                        var cookie = new Cookie(
+                            restResponseCookie.Name,
+                            restResponseCookie.Value,
+                            restResponseCookie.Path,
+                            restResponseCookie.Domain
+                        )
+                        {
+                            Comment = restResponseCookie.Comment,
+                            CommentUri = restResponseCookie.CommentUri,
+                            Discard = restResponseCookie.Discard,
+                            Expired = restResponseCookie.Expired,
+                            Expires = restResponseCookie.Expires,
+                            HttpOnly = restResponseCookie.HttpOnly,
+                            Port = restResponseCookie.Port,
+                            Secure = restResponseCookie.Secure,
+                            Version = restResponseCookie.Version
+                        };
+
+                        result.Cookies.Add(cookie);
+                    }
+                }
+
+                var exceptionFactory = SeamRequestConfiguration.DefaultExceptionFactory;
+                if (exceptionFactory != null)
+                {
+                    var exception = exceptionFactory(request.Resource, result);
+                    if (exception != null)
+                    {
+                        throw exception;
+                    }
+                }
+
+                return result;
+            }
+        }
+
+        #region IAsynchronousClient
+        /// <summary>
+        /// Make a HTTP GET request (async).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <param name="cancellationToken">Token that enables callers to cancel the request.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public Task<ApiResponse<T>> GetAsync<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null,
+            System.Threading.CancellationToken cancellationToken =
+                default(System.Threading.CancellationToken)
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return ExecAsync<T>(
+                NewRequest(HttpMethod.Get, path, options, config),
+                options,
+                config,
+                cancellationToken
+            );
+        }
+
+        /// <summary>
+        /// Make a HTTP POST request (async).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <param name="cancellationToken">Token that enables callers to cancel the request.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public Task<ApiResponse<T>> PostAsync<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null,
+            System.Threading.CancellationToken cancellationToken =
+                default(System.Threading.CancellationToken)
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return ExecAsync<T>(
+                NewRequest(HttpMethod.Post, path, options, config),
+                options,
+                config,
+                cancellationToken
+            );
+        }
+
+        /// <summary>
+        /// Make a HTTP PUT request (async).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <param name="cancellationToken">Token that enables callers to cancel the request.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public Task<ApiResponse<T>> PutAsync<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null,
+            System.Threading.CancellationToken cancellationToken =
+                default(System.Threading.CancellationToken)
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return ExecAsync<T>(
+                NewRequest(HttpMethod.Put, path, options, config),
+                options,
+                config,
+                cancellationToken
+            );
+        }
+
+        /// <summary>
+        /// Make a HTTP DELETE request (async).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <param name="cancellationToken">Token that enables callers to cancel the request.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public Task<ApiResponse<T>> DeleteAsync<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null,
+            System.Threading.CancellationToken cancellationToken =
+                default(System.Threading.CancellationToken)
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return ExecAsync<T>(
+                NewRequest(HttpMethod.Delete, path, options, config),
+                options,
+                config,
+                cancellationToken
+            );
+        }
+
+        /// <summary>
+        /// Make a HTTP HEAD request (async).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <param name="cancellationToken">Token that enables callers to cancel the request.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public Task<ApiResponse<T>> HeadAsync<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null,
+            System.Threading.CancellationToken cancellationToken =
+                default(System.Threading.CancellationToken)
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return ExecAsync<T>(
+                NewRequest(HttpMethod.Head, path, options, config),
+                options,
+                config,
+                cancellationToken
+            );
+        }
+
+        /// <summary>
+        /// Make a HTTP OPTION request (async).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <param name="cancellationToken">Token that enables callers to cancel the request.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public Task<ApiResponse<T>> OptionsAsync<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null,
+            System.Threading.CancellationToken cancellationToken =
+                default(System.Threading.CancellationToken)
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return ExecAsync<T>(
+                NewRequest(HttpMethod.Options, path, options, config),
+                options,
+                config,
+                cancellationToken
+            );
+        }
+
+        /// <summary>
+        /// Make a HTTP PATCH request (async).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <param name="cancellationToken">Token that enables callers to cancel the request.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public Task<ApiResponse<T>> PatchAsync<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null,
+            System.Threading.CancellationToken cancellationToken =
+                default(System.Threading.CancellationToken)
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return ExecAsync<T>(
+                NewRequest(HttpMethod.Patch, path, options, config),
+                options,
+                config,
+                cancellationToken
+            );
+        }
+        #endregion IAsynchronousClient
+
+        #region ISynchronousClient
+        /// <summary>
+        /// Make a HTTP GET request (synchronous).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public ApiResponse<T> Get<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return Exec<T>(NewRequest(HttpMethod.Get, path, options, config), options, config);
+        }
+
+        /// <summary>
+        /// Make a HTTP POST request (synchronous).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public ApiResponse<T> Post<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return Exec<T>(NewRequest(HttpMethod.Post, path, options, config), options, config);
+        }
+
+        /// <summary>
+        /// Make a HTTP PUT request (synchronous).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public ApiResponse<T> Put<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return Exec<T>(NewRequest(HttpMethod.Put, path, options, config), options, config);
+        }
+
+        /// <summary>
+        /// Make a HTTP DELETE request (synchronous).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public ApiResponse<T> Delete<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return Exec<T>(NewRequest(HttpMethod.Delete, path, options, config), options, config);
+        }
+
+        /// <summary>
+        /// Make a HTTP HEAD request (synchronous).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public ApiResponse<T> Head<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return Exec<T>(NewRequest(HttpMethod.Head, path, options, config), options, config);
+        }
+
+        /// <summary>
+        /// Make a HTTP OPTION request (synchronous).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public ApiResponse<T> Options<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return Exec<T>(NewRequest(HttpMethod.Options, path, options, config), options, config);
+        }
+
+        /// <summary>
+        /// Make a HTTP PATCH request (synchronous).
+        /// </summary>
+        /// <param name="path">The target path (or resource).</param>
+        /// <param name="options">The additional request options.</param>
+        /// <param name="configuration">A per-request configuration object. It is assumed that any merge with
+        /// GlobalSeamConfiguration has been done before calling this method.</param>
+        /// <returns>A Task containing ApiResponse</returns>
+        public ApiResponse<T> Patch<T>(
+            string path,
+            RequestOptions options,
+            IReadableSeamRequestConfiguration configuration = null
+        )
+        {
+            var config = configuration ?? GlobalSeamRequestConfiguration.Instance;
+            return Exec<T>(NewRequest(HttpMethod.Patch, path, options, config), options, config);
+        }
+
+        #endregion ISynchronousClient
+        public void Dispose() { }
+    }
+
+    [Obsolete("Please use Seam.Client.SeamClient instead")]
+    public class Seam : SeamClient
+    {
+        public Seam(string apiToken)
+            : base(apiToken) { }
+
+        public Seam(string basePath, string apiToken)
+            : base(basePath, apiToken) { }
+    }
+}