/* 
 * InfluxDB OSS API Service
 *
 * The InfluxDB v2 API provides a programmatic interface for all interactions with InfluxDB. Access the InfluxDB API using the `/api/v2/` endpoint. 
 *
 * OpenAPI spec version: 2.0.0
 * 
 * Generated by: https://github.com/openapitools/openapi-generator.git
 */

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading;
using RestSharp;
using InfluxDB.Client.Api.Client;
using InfluxDB.Client.Api.Domain;

namespace InfluxDB.Client.Api.Service
{
    /// <summary>
    /// Represents a collection of functions to interact with the API endpoints
    /// </summary>
    public interface IRestoreService : IApiAccessor
    {
        #region Synchronous Operations

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>byte[]</returns>
        byte[] PostRestoreBucketID(string bucketID, byte[] body, string zapTraceSpan = null, string contentType = null);

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of byte[]</returns>
        ApiResponse<byte[]> PostRestoreBucketIDWithHttpInfo(string bucketID, byte[] body, string zapTraceSpan = null,
            string contentType = null);

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>RestoredBucketMappings</returns>
        RestoredBucketMappings PostRestoreBucketMetadata(BucketMetadataManifest bucketMetadataManifest,
            string zapTraceSpan = null);

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of RestoredBucketMappings</returns>
        ApiResponse<RestoredBucketMappings> PostRestoreBucketMetadataWithHttpInfo(
            BucketMetadataManifest bucketMetadataManifest, string zapTraceSpan = null);

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>PostRestoreKVResponse</returns>
        PostRestoreKVResponse PostRestoreKV(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null);

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of PostRestoreKVResponse</returns>
        ApiResponse<PostRestoreKVResponse> PostRestoreKVWithHttpInfo(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null);

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns></returns>
        void PostRestoreSQL(System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null,
            string contentType = null);

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> PostRestoreSQLWithHttpInfo(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null);

        /// <summary>
        /// Restore a TSM snapshot into a shard.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns></returns>
        void PostRestoreShardId(string shardID, System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null);

        /// <summary>
        /// Restore a TSM snapshot into a shard.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> PostRestoreShardIdWithHttpInfo(string shardID, System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null);

        #endregion Synchronous Operations

        #region Asynchronous Operations

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of byte[]</returns>
        System.Threading.Tasks.Task<byte[]> PostRestoreBucketIDAsync(string bucketID, byte[] body,
            string zapTraceSpan = null, string contentType = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (byte[])</returns>
        System.Threading.Tasks.Task<ApiResponse<byte[]>> PostRestoreBucketIDAsyncWithHttpInfo(string bucketID,
            byte[] body, string zapTraceSpan = null, string contentType = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestoredBucketMappings</returns>
        System.Threading.Tasks.Task<RestoredBucketMappings> PostRestoreBucketMetadataAsync(
            BucketMetadataManifest bucketMetadataManifest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (RestoredBucketMappings)</returns>
        System.Threading.Tasks.Task<ApiResponse<RestoredBucketMappings>> PostRestoreBucketMetadataAsyncWithHttpInfo(
            BucketMetadataManifest bucketMetadataManifest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of PostRestoreKVResponse</returns>
        System.Threading.Tasks.Task<PostRestoreKVResponse> PostRestoreKVAsync(System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (PostRestoreKVResponse)</returns>
        System.Threading.Tasks.Task<ApiResponse<PostRestoreKVResponse>> PostRestoreKVAsyncWithHttpInfo(
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        System.Threading.Tasks.Task PostRestoreSQLAsync(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        System.Threading.Tasks.Task<ApiResponse<object>> PostRestoreSQLAsyncWithHttpInfo(System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Restore a TSM snapshot into a shard.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        System.Threading.Tasks.Task PostRestoreShardIdAsync(string shardID, System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Restore a TSM snapshot into a shard.
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        System.Threading.Tasks.Task<ApiResponse<object>> PostRestoreShardIdAsyncWithHttpInfo(string shardID,
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default);

        #endregion Asynchronous Operations
    }

    /// <summary>
    /// Represents a collection of functions to interact with the API endpoints
    /// </summary>
    public partial class RestoreService : IRestoreService
    {
        private ExceptionFactory _exceptionFactory = (name, response) => null;

        /// <summary>
        /// Initializes a new instance of the <see cref="RestoreService"/> class.
        /// </summary>
        /// <returns></returns>
        public RestoreService(string basePath)
        {
            Configuration = new Configuration { BasePath = basePath };

            ExceptionFactory = Configuration.DefaultExceptionFactory;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RestoreService"/> class
        /// using Configuration object
        /// </summary>
        /// <param name="configuration">An instance of Configuration</param>
        /// <returns></returns>
        public RestoreService(Configuration configuration = null)
        {
            if (configuration == null) // use the default one in Configuration
            {
                Configuration = Configuration.Default;
            }
            else
            {
                Configuration = configuration;
            }

            ExceptionFactory = Configuration.DefaultExceptionFactory;
        }

        /// <summary>
        /// Gets the base path of the API client.
        /// </summary>
        /// <value>The base path</value>
        public string GetBasePath()
        {
            return Configuration.ApiClient.RestClientOptions.BaseUrl.ToString();
        }

        /// <summary>
        /// Sets the base path of the API client.
        /// </summary>
        /// <value>The base path</value>
        [Obsolete(
            "SetBasePath is deprecated, please do 'Configuration.ApiClient = new ApiClient(\"http://new-path\")' instead.")]
        public void SetBasePath(string basePath)
        {
            // do nothing
        }

        /// <summary>
        /// Gets or sets the configuration object
        /// </summary>
        /// <value>An instance of the Configuration</value>
        public Configuration Configuration { get; set; }

        /// <summary>
        /// Provides a factory method hook for the creation of exceptions.
        /// </summary>
        public ExceptionFactory ExceptionFactory
        {
            get
            {
                if (_exceptionFactory != null && _exceptionFactory.GetInvocationList().Length > 1)
                {
                    throw new InvalidOperationException("Multicast delegate for ExceptionFactory is unsupported.");
                }

                return _exceptionFactory;
            }
            set => _exceptionFactory = value;
        }

        /// <summary>
        /// Gets the default header.
        /// </summary>
        /// <returns>Dictionary of HTTP header</returns>
        [Obsolete("DefaultHeader is deprecated, please use Configuration.DefaultHeader instead.")]
        public IDictionary<string, string> DefaultHeader()
        {
            return new ReadOnlyDictionary<string, string>(Configuration.DefaultHeader);
        }

        /// <summary>
        /// Add default header.
        /// </summary>
        /// <param name="key">Header field name.</param>
        /// <param name="value">Header field value.</param>
        /// <returns></returns>
        [Obsolete("AddDefaultHeader is deprecated, please use Configuration.AddDefaultHeader instead.")]
        public void AddDefaultHeader(string key, string value)
        {
            Configuration.AddDefaultHeader(key, value);
        }

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>byte[]</returns>
        public byte[] PostRestoreBucketID(string bucketID, byte[] body, string zapTraceSpan = null,
            string contentType = null)
        {
            var localVarResponse = PostRestoreBucketIDWithHttpInfo(bucketID, body, zapTraceSpan, contentType);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of byte[]</returns>
        public ApiResponse<byte[]> PostRestoreBucketIDWithHttpInfo(string bucketID, byte[] body,
            string zapTraceSpan = null, string contentType = null)
        {
            // verify the required parameter 'bucketID' is set
            if (bucketID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketID' when calling RestoreService->PostRestoreBucketID");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreBucketID");
            }

            var localVarPath = "/api/v2/restore/bucket/{bucketID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (bucketID != null)
            {
                localVarPathParams.Add("bucketID",
                    Configuration.ApiClient.ParameterToString(bucketID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<byte[]>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                (byte[])Configuration.ApiClient.Deserialize(localVarResponse, typeof(byte[])));
        }

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of byte[]</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreBucketIDWithIRestResponseAsync(
            string bucketID, byte[] body, string zapTraceSpan = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'bucketID' is set
            if (bucketID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketID' when calling RestoreService->PostRestoreBucketID");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreBucketID");
            }

            var localVarPath = "/api/v2/restore/bucket/{bucketID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (bucketID != null)
            {
                localVarPathParams.Add("bucketID",
                    Configuration.ApiClient.ParameterToString(bucketID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of byte[]</returns>
        public RestResponse PostRestoreBucketIDWithIRestResponse(string bucketID, byte[] body,
            string zapTraceSpan = null, string contentType = null)
        {
            // verify the required parameter 'bucketID' is set
            if (bucketID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketID' when calling RestoreService->PostRestoreBucketID");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreBucketID");
            }

            var localVarPath = "/api/v2/restore/bucket/{bucketID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (bucketID != null)
            {
                localVarPathParams.Add("bucketID",
                    Configuration.ApiClient.ParameterToString(bucketID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of byte[]</returns>
        public RestRequest PostRestoreBucketIDWithRestRequest(string bucketID, byte[] body, string zapTraceSpan = null,
            string contentType = null)
        {
            // verify the required parameter 'bucketID' is set
            if (bucketID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketID' when calling RestoreService->PostRestoreBucketID");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreBucketID");
            }

            var localVarPath = "/api/v2/restore/bucket/{bucketID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (bucketID != null)
            {
                localVarPathParams.Add("bucketID",
                    Configuration.ApiClient.ParameterToString(bucketID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            return Configuration.ApiClient.PrepareRequest(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of byte[]</returns>
        public async System.Threading.Tasks.Task<byte[]> PostRestoreBucketIDAsync(string bucketID, byte[] body,
            string zapTraceSpan = null, string contentType = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostRestoreBucketIDAsyncWithHttpInfo(bucketID, body, zapTraceSpan, contentType, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (byte[])</returns>
        public async System.Threading.Tasks.Task<ApiResponse<byte[]>> PostRestoreBucketIDAsyncWithHttpInfo(
            string bucketID, byte[] body, string zapTraceSpan = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostRestoreBucketIDAsyncWithIRestResponse(bucketID, body, zapTraceSpan, contentType,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<byte[]>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                (byte[])Configuration.ApiClient.Deserialize(localVarResponse, typeof(byte[])));
        }

        /// <summary>
        /// Overwrite storage metadata for a bucket with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketID">The bucket ID.</param>
        /// <param name="body">Database info serialized as protobuf.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (byte[])</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreBucketIDAsyncWithIRestResponse(
            string bucketID, byte[] body, string zapTraceSpan = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'bucketID' is set
            if (bucketID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketID' when calling RestoreService->PostRestoreBucketID");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreBucketID");
            }

            var localVarPath = "/api/v2/restore/bucket/{bucketID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (bucketID != null)
            {
                localVarPathParams.Add("bucketID",
                    Configuration.ApiClient.ParameterToString(bucketID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>RestoredBucketMappings</returns>
        public RestoredBucketMappings PostRestoreBucketMetadata(BucketMetadataManifest bucketMetadataManifest,
            string zapTraceSpan = null)
        {
            var localVarResponse = PostRestoreBucketMetadataWithHttpInfo(bucketMetadataManifest, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of RestoredBucketMappings</returns>
        public ApiResponse<RestoredBucketMappings> PostRestoreBucketMetadataWithHttpInfo(
            BucketMetadataManifest bucketMetadataManifest, string zapTraceSpan = null)
        {
            // verify the required parameter 'bucketMetadataManifest' is set
            if (bucketMetadataManifest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketMetadataManifest' when calling RestoreService->PostRestoreBucketMetadata");
            }

            var localVarPath = "/api/v2/restore/bucketMetadata";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "application/json"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (bucketMetadataManifest != null && bucketMetadataManifest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(bucketMetadataManifest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = bucketMetadataManifest; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketMetadata", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<RestoredBucketMappings>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                (RestoredBucketMappings)Configuration.ApiClient.Deserialize(localVarResponse,
                    typeof(RestoredBucketMappings)));
        }

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of RestoredBucketMappings</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreBucketMetadataWithIRestResponseAsync(
            BucketMetadataManifest bucketMetadataManifest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'bucketMetadataManifest' is set
            if (bucketMetadataManifest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketMetadataManifest' when calling RestoreService->PostRestoreBucketMetadata");
            }

            var localVarPath = "/api/v2/restore/bucketMetadata";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "application/json"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (bucketMetadataManifest != null && bucketMetadataManifest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(bucketMetadataManifest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = bucketMetadataManifest; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketMetadata", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of RestoredBucketMappings</returns>
        public RestResponse PostRestoreBucketMetadataWithIRestResponse(BucketMetadataManifest bucketMetadataManifest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'bucketMetadataManifest' is set
            if (bucketMetadataManifest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketMetadataManifest' when calling RestoreService->PostRestoreBucketMetadata");
            }

            var localVarPath = "/api/v2/restore/bucketMetadata";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "application/json"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (bucketMetadataManifest != null && bucketMetadataManifest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(bucketMetadataManifest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = bucketMetadataManifest; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketMetadata", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of RestoredBucketMappings</returns>
        public RestRequest PostRestoreBucketMetadataWithRestRequest(BucketMetadataManifest bucketMetadataManifest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'bucketMetadataManifest' is set
            if (bucketMetadataManifest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketMetadataManifest' when calling RestoreService->PostRestoreBucketMetadata");
            }

            var localVarPath = "/api/v2/restore/bucketMetadata";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "application/json"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (bucketMetadataManifest != null && bucketMetadataManifest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(bucketMetadataManifest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = bucketMetadataManifest; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            return Configuration.ApiClient.PrepareRequest(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestoredBucketMappings</returns>
        public async System.Threading.Tasks.Task<RestoredBucketMappings> PostRestoreBucketMetadataAsync(
            BucketMetadataManifest bucketMetadataManifest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostRestoreBucketMetadataAsyncWithHttpInfo(bucketMetadataManifest, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (RestoredBucketMappings)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<RestoredBucketMappings>>
            PostRestoreBucketMetadataAsyncWithHttpInfo(BucketMetadataManifest bucketMetadataManifest,
                string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostRestoreBucketMetadataAsyncWithIRestResponse(bucketMetadataManifest, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketMetadata", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<RestoredBucketMappings>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                (RestoredBucketMappings)Configuration.ApiClient.Deserialize(localVarResponse,
                    typeof(RestoredBucketMappings)));
        }

        /// <summary>
        /// Create a new bucket pre-seeded with shard info from a backup. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="bucketMetadataManifest">Metadata manifest for a bucket.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (RestoredBucketMappings)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreBucketMetadataAsyncWithIRestResponse(
            BucketMetadataManifest bucketMetadataManifest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'bucketMetadataManifest' is set
            if (bucketMetadataManifest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'bucketMetadataManifest' when calling RestoreService->PostRestoreBucketMetadata");
            }

            var localVarPath = "/api/v2/restore/bucketMetadata";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "application/json"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (bucketMetadataManifest != null && bucketMetadataManifest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(bucketMetadataManifest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = bucketMetadataManifest; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreBucketMetadata", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>PostRestoreKVResponse</returns>
        public PostRestoreKVResponse PostRestoreKV(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null)
        {
            var localVarResponse = PostRestoreKVWithHttpInfo(body, zapTraceSpan, contentEncoding, contentType);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of PostRestoreKVResponse</returns>
        public ApiResponse<PostRestoreKVResponse> PostRestoreKVWithHttpInfo(System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreKV");
            }

            var localVarPath = "/api/v2/restore/kv";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreKV", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<PostRestoreKVResponse>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                (PostRestoreKVResponse)Configuration.ApiClient.Deserialize(localVarResponse,
                    typeof(PostRestoreKVResponse)));
        }

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of PostRestoreKVResponse</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreKVWithIRestResponseAsync(
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreKV");
            }

            var localVarPath = "/api/v2/restore/kv";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreKV", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of PostRestoreKVResponse</returns>
        public RestResponse PostRestoreKVWithIRestResponse(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreKV");
            }

            var localVarPath = "/api/v2/restore/kv";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreKV", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of PostRestoreKVResponse</returns>
        public RestRequest PostRestoreKVWithRestRequest(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreKV");
            }

            var localVarPath = "/api/v2/restore/kv";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            return Configuration.ApiClient.PrepareRequest(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of PostRestoreKVResponse</returns>
        public async System.Threading.Tasks.Task<PostRestoreKVResponse> PostRestoreKVAsync(System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostRestoreKVAsyncWithHttpInfo(body, zapTraceSpan, contentEncoding, contentType,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (PostRestoreKVResponse)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<PostRestoreKVResponse>> PostRestoreKVAsyncWithHttpInfo(
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostRestoreKVAsyncWithIRestResponse(body, zapTraceSpan, contentEncoding, contentType,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreKV", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<PostRestoreKVResponse>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                (PostRestoreKVResponse)Configuration.ApiClient.Deserialize(localVarResponse,
                    typeof(PostRestoreKVResponse)));
        }

        /// <summary>
        /// Overwrite the embedded KV store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full KV snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (PostRestoreKVResponse)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreKVAsyncWithIRestResponse(
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreKV");
            }

            var localVarPath = "/api/v2/restore/kv";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreKV", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns></returns>
        public void PostRestoreSQL(System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null,
            string contentType = null)
        {
            PostRestoreSQLWithHttpInfo(body, zapTraceSpan, contentEncoding, contentType);
        }

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> PostRestoreSQLWithHttpInfo(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreSQL");
            }

            var localVarPath = "/api/v2/restore/sql";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreSQL", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<object>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                null);
        }

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreSQLWithIRestResponseAsync(
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreSQL");
            }

            var localVarPath = "/api/v2/restore/sql";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreSQL", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse PostRestoreSQLWithIRestResponse(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreSQL");
            }

            var localVarPath = "/api/v2/restore/sql";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreSQL", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest PostRestoreSQLWithRestRequest(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreSQL");
            }

            var localVarPath = "/api/v2/restore/sql";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            return Configuration.ApiClient.PrepareRequest(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        public System.Threading.Tasks.Task PostRestoreSQLAsync(System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null, CancellationToken cancellationToken = default)
        {
            return PostRestoreSQLAsyncWithHttpInfo(body, zapTraceSpan, contentEncoding, contentType, cancellationToken);
        }

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        public async System.Threading.Tasks.Task<ApiResponse<object>> PostRestoreSQLAsyncWithHttpInfo(
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostRestoreSQLAsyncWithIRestResponse(body, zapTraceSpan, contentEncoding, contentType,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreSQL", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<object>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                null);
        }

        /// <summary>
        /// Overwrite the embedded SQL store on the server with a backed-up snapshot. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="body">Full SQL snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreSQLAsyncWithIRestResponse(
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreSQL");
            }

            var localVarPath = "/api/v2/restore/sql";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreSQL", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Restore a TSM snapshot into a shard. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns></returns>
        public void PostRestoreShardId(string shardID, System.IO.Stream body, string zapTraceSpan = null,
            string contentEncoding = null, string contentType = null)
        {
            PostRestoreShardIdWithHttpInfo(shardID, body, zapTraceSpan, contentEncoding, contentType);
        }

        /// <summary>
        /// Restore a TSM snapshot into a shard. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> PostRestoreShardIdWithHttpInfo(string shardID, System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null)
        {
            // verify the required parameter 'shardID' is set
            if (shardID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'shardID' when calling RestoreService->PostRestoreShardId");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreShardId");
            }

            var localVarPath = "/api/v2/restore/shards/{shardID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (shardID != null)
            {
                localVarPathParams.Add("shardID", Configuration.ApiClient.ParameterToString(shardID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreShardId", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<object>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                null);
        }

        /// <summary>
        /// Restore a TSM snapshot into a shard. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreShardIdWithIRestResponseAsync(string shardID,
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'shardID' is set
            if (shardID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'shardID' when calling RestoreService->PostRestoreShardId");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreShardId");
            }

            var localVarPath = "/api/v2/restore/shards/{shardID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (shardID != null)
            {
                localVarPathParams.Add("shardID", Configuration.ApiClient.ParameterToString(shardID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreShardId", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Restore a TSM snapshot into a shard. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse PostRestoreShardIdWithIRestResponse(string shardID, System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null)
        {
            // verify the required parameter 'shardID' is set
            if (shardID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'shardID' when calling RestoreService->PostRestoreShardId");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreShardId");
            }

            var localVarPath = "/api/v2/restore/shards/{shardID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (shardID != null)
            {
                localVarPathParams.Add("shardID", Configuration.ApiClient.ParameterToString(shardID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)Configuration.ApiClient.CallApi(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreShardId", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Restore a TSM snapshot into a shard. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest PostRestoreShardIdWithRestRequest(string shardID, System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null)
        {
            // verify the required parameter 'shardID' is set
            if (shardID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'shardID' when calling RestoreService->PostRestoreShardId");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreShardId");
            }

            var localVarPath = "/api/v2/restore/shards/{shardID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (shardID != null)
            {
                localVarPathParams.Add("shardID", Configuration.ApiClient.ParameterToString(shardID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            return Configuration.ApiClient.PrepareRequest(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// Restore a TSM snapshot into a shard. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        public System.Threading.Tasks.Task PostRestoreShardIdAsync(string shardID, System.IO.Stream body,
            string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            return PostRestoreShardIdAsyncWithHttpInfo(shardID, body, zapTraceSpan, contentEncoding, contentType,
                cancellationToken);
        }

        /// <summary>
        /// Restore a TSM snapshot into a shard. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        public async System.Threading.Tasks.Task<ApiResponse<object>> PostRestoreShardIdAsyncWithHttpInfo(
            string shardID, System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null,
            string contentType = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostRestoreShardIdAsyncWithIRestResponse(shardID, body, zapTraceSpan, contentEncoding,
                    contentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreShardId", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return new ApiResponse<object>(localVarStatusCode,
                localVarResponse.Headers.Select(h => (h.Name, h.Value)),
                null);
        }

        /// <summary>
        /// Restore a TSM snapshot into a shard. 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="shardID">The shard ID.</param>
        /// <param name="body">TSM snapshot.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="contentEncoding">The value tells InfluxDB what compression is applied to the line protocol in the request payload. To make an API request with a GZIP payload, send &#x60;Content-Encoding: gzip&#x60; as a request header. (optional, default to identity)</param>
        /// <param name="contentType"> (optional, default to application/octet-stream)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostRestoreShardIdAsyncWithIRestResponse(string shardID,
            System.IO.Stream body, string zapTraceSpan = null, string contentEncoding = null, string contentType = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'shardID' is set
            if (shardID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'shardID' when calling RestoreService->PostRestoreShardId");
            }

            // verify the required parameter 'body' is set
            if (body == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'body' when calling RestoreService->PostRestoreShardId");
            }

            var localVarPath = "/api/v2/restore/shards/{shardID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
                "text/plain"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (shardID != null)
            {
                localVarPathParams.Add("shardID", Configuration.ApiClient.ParameterToString(shardID)); // path parameter
            }

            if (zapTraceSpan != null)
            {
                localVarHeaderParams.Add("Zap-Trace-Span",
                    Configuration.ApiClient.ParameterToString(zapTraceSpan)); // header parameter
            }

            if (contentEncoding != null)
            {
                localVarHeaderParams.Add("Content-Encoding",
                    Configuration.ApiClient.ParameterToString(contentEncoding)); // header parameter
            }

            if (contentType != null)
            {
                localVarHeaderParams.Add("Content-Type",
                    Configuration.ApiClient.ParameterToString(contentType)); // header parameter
            }

            if (body != null && body.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(body); // http body (model) parameter
            }
            else
            {
                localVarPostBody = body; // byte array
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/json"
            };

            var localVarHttpHeaderAccept = Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts);
            if (localVarHttpHeaderAccept != null && !localVarHeaderParams.ContainsKey("Accept"))
            {
                localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept);
            }


            // make the HTTP request
            var localVarResponse = (RestResponse)await Configuration.ApiClient.CallApiAsync(localVarPath,
                Method.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostRestoreShardId", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }
    }
}