/* 
 * 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 ILegacyAuthorizationsService : IApiAccessor
    {
        #region Synchronous Operations

        /// <summary>
        /// Delete a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        void DeleteLegacyAuthorizationsID(string authID, string zapTraceSpan = null);

        /// <summary>
        /// Delete a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> DeleteLegacyAuthorizationsIDWithHttpInfo(string authID, string zapTraceSpan = null);

        /// <summary>
        /// List all legacy authorizations
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <returns>Authorizations</returns>
        Authorizations GetLegacyAuthorizations(string zapTraceSpan = null, string userID = null, string user = null,
            string orgID = null, string org = null, string token = null, string authID = null);

        /// <summary>
        /// List all legacy authorizations
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <returns>ApiResponse of Authorizations</returns>
        ApiResponse<Authorizations> GetLegacyAuthorizationsWithHttpInfo(string zapTraceSpan = null,
            string userID = null, string user = null, string orgID = null, string org = null, string token = null,
            string authID = null);

        /// <summary>
        /// Retrieve a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Authorization</returns>
        Authorization GetLegacyAuthorizationsID(string authID, string zapTraceSpan = null);

        /// <summary>
        /// Retrieve a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        ApiResponse<Authorization> GetLegacyAuthorizationsIDWithHttpInfo(string authID, string zapTraceSpan = null);

        /// <summary>
        /// Update a legacy authorization to be active or inactive
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Authorization</returns>
        Authorization PatchLegacyAuthorizationsID(string authID, AuthorizationUpdateRequest authorizationUpdateRequest,
            string zapTraceSpan = null);

        /// <summary>
        /// Update a legacy authorization to be active or inactive
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        ApiResponse<Authorization> PatchLegacyAuthorizationsIDWithHttpInfo(string authID,
            AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null);

        /// <summary>
        /// Create a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Authorization</returns>
        Authorization PostLegacyAuthorizations(LegacyAuthorizationPostRequest legacyAuthorizationPostRequest,
            string zapTraceSpan = null);

        /// <summary>
        /// Create a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        ApiResponse<Authorization> PostLegacyAuthorizationsWithHttpInfo(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null);

        /// <summary>
        /// Set a legacy authorization password
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        void PostLegacyAuthorizationsIDPassword(string authID, PasswordResetBody passwordResetBody,
            string zapTraceSpan = null);

        /// <summary>
        /// Set a legacy authorization password
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> PostLegacyAuthorizationsIDPasswordWithHttpInfo(string authID,
            PasswordResetBody passwordResetBody, string zapTraceSpan = null);

        #endregion Synchronous Operations

        #region Asynchronous Operations

        /// <summary>
        /// Delete a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        System.Threading.Tasks.Task DeleteLegacyAuthorizationsIDAsync(string authID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Delete a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        System.Threading.Tasks.Task<ApiResponse<object>> DeleteLegacyAuthorizationsIDAsyncWithHttpInfo(string authID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all legacy authorizations
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Authorizations</returns>
        System.Threading.Tasks.Task<Authorizations> GetLegacyAuthorizationsAsync(string zapTraceSpan = null,
            string userID = null, string user = null, string orgID = null, string org = null, string token = null,
            string authID = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all legacy authorizations
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Authorizations)</returns>
        System.Threading.Tasks.Task<ApiResponse<Authorizations>> GetLegacyAuthorizationsAsyncWithHttpInfo(
            string zapTraceSpan = null, string userID = null, string user = null, string orgID = null,
            string org = null, string token = null, string authID = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Authorization</returns>
        System.Threading.Tasks.Task<Authorization> GetLegacyAuthorizationsIDAsync(string authID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Authorization)</returns>
        System.Threading.Tasks.Task<ApiResponse<Authorization>> GetLegacyAuthorizationsIDAsyncWithHttpInfo(
            string authID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a legacy authorization to be active or inactive
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Authorization</returns>
        System.Threading.Tasks.Task<Authorization> PatchLegacyAuthorizationsIDAsync(string authID,
            AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a legacy authorization to be active or inactive
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Authorization)</returns>
        System.Threading.Tasks.Task<ApiResponse<Authorization>> PatchLegacyAuthorizationsIDAsyncWithHttpInfo(
            string authID, AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Create a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Authorization</returns>
        System.Threading.Tasks.Task<Authorization> PostLegacyAuthorizationsAsync(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Create a legacy authorization
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Authorization)</returns>
        System.Threading.Tasks.Task<ApiResponse<Authorization>> PostLegacyAuthorizationsAsyncWithHttpInfo(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Set a legacy authorization password
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        System.Threading.Tasks.Task PostLegacyAuthorizationsIDPasswordAsync(string authID,
            PasswordResetBody passwordResetBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Set a legacy authorization password
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        System.Threading.Tasks.Task<ApiResponse<object>> PostLegacyAuthorizationsIDPasswordAsyncWithHttpInfo(
            string authID, PasswordResetBody passwordResetBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        #endregion Asynchronous Operations
    }

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

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

            ExceptionFactory = Configuration.DefaultExceptionFactory;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LegacyAuthorizationsService"/> class
        /// using Configuration object
        /// </summary>
        /// <param name="configuration">An instance of Configuration</param>
        /// <returns></returns>
        public LegacyAuthorizationsService(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>
        /// Delete a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteLegacyAuthorizationsID(string authID, string zapTraceSpan = null)
        {
            DeleteLegacyAuthorizationsIDWithHttpInfo(authID, zapTraceSpan);
        }

        /// <summary>
        /// Delete a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> DeleteLegacyAuthorizationsIDWithHttpInfo(string authID, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->DeleteLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Delete, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Delete a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public async System.Threading.Tasks.Task<RestResponse> DeleteLegacyAuthorizationsIDWithIRestResponseAsync(
            string authID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->DeleteLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Delete, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Delete a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse DeleteLegacyAuthorizationsIDWithIRestResponse(string authID, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->DeleteLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Delete, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Delete a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest DeleteLegacyAuthorizationsIDWithRestRequest(string authID, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->DeleteLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Delete, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// Delete a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        public System.Threading.Tasks.Task DeleteLegacyAuthorizationsIDAsync(string authID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            return DeleteLegacyAuthorizationsIDAsyncWithHttpInfo(authID, zapTraceSpan, cancellationToken);
        }

        /// <summary>
        /// Delete a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        public async System.Threading.Tasks.Task<ApiResponse<object>> DeleteLegacyAuthorizationsIDAsyncWithHttpInfo(
            string authID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await DeleteLegacyAuthorizationsIDAsyncWithIRestResponse(authID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Delete a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse</returns>
        public async System.Threading.Tasks.Task<RestResponse> DeleteLegacyAuthorizationsIDAsyncWithIRestResponse(
            string authID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->DeleteLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Delete, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

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

            return localVarResponse;
        }

        /// <summary>
        /// List all legacy authorizations 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <returns>Authorizations</returns>
        public Authorizations GetLegacyAuthorizations(string zapTraceSpan = null, string userID = null,
            string user = null, string orgID = null, string org = null, string token = null, string authID = null)
        {
            var localVarResponse =
                GetLegacyAuthorizationsWithHttpInfo(zapTraceSpan, userID, user, orgID, org, token, authID);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all legacy authorizations 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <returns>ApiResponse of Authorizations</returns>
        public ApiResponse<Authorizations> GetLegacyAuthorizationsWithHttpInfo(string zapTraceSpan = null,
            string userID = null, string user = null, string orgID = null, string org = null, string token = null,
            string authID = null)
        {
            var localVarPath = "/private/legacy/authorizations";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (userID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "userID", userID)); // query parameter
            }

            if (user != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "user", user)); // query parameter
            }

            if (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // query parameter
            }

            if (org != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "org", org)); // query parameter
            }

            if (token != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "token", token)); // query parameter
            }

            if (authID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "authID", authID)); // query parameter
            }

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List all legacy authorizations 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Authorizations</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetLegacyAuthorizationsWithIRestResponseAsync(
            string zapTraceSpan = null, string userID = null, string user = null, string orgID = null,
            string org = null, string token = null, string authID = null, CancellationToken cancellationToken = default)
        {
            var localVarPath = "/private/legacy/authorizations";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (userID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "userID", userID)); // query parameter
            }

            if (user != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "user", user)); // query parameter
            }

            if (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // query parameter
            }

            if (org != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "org", org)); // query parameter
            }

            if (token != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "token", token)); // query parameter
            }

            if (authID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "authID", authID)); // query parameter
            }

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// List all legacy authorizations 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <returns>ApiResponse of Authorizations</returns>
        public RestResponse GetLegacyAuthorizationsWithIRestResponse(string zapTraceSpan = null, string userID = null,
            string user = null, string orgID = null, string org = null, string token = null, string authID = null)
        {
            var localVarPath = "/private/legacy/authorizations";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (userID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "userID", userID)); // query parameter
            }

            if (user != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "user", user)); // query parameter
            }

            if (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // query parameter
            }

            if (org != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "org", org)); // query parameter
            }

            if (token != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "token", token)); // query parameter
            }

            if (authID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "authID", authID)); // query parameter
            }

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// List all legacy authorizations 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <returns>ApiResponse of Authorizations</returns>
        public RestRequest GetLegacyAuthorizationsWithRestRequest(string zapTraceSpan = null, string userID = null,
            string user = null, string orgID = null, string org = null, string token = null, string authID = null)
        {
            var localVarPath = "/private/legacy/authorizations";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (userID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "userID", userID)); // query parameter
            }

            if (user != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "user", user)); // query parameter
            }

            if (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // query parameter
            }

            if (org != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "org", org)); // query parameter
            }

            if (token != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "token", token)); // query parameter
            }

            if (authID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "authID", authID)); // query parameter
            }

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// List all legacy authorizations 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Authorizations</returns>
        public async System.Threading.Tasks.Task<Authorizations> GetLegacyAuthorizationsAsync(
            string zapTraceSpan = null, string userID = null, string user = null, string orgID = null,
            string org = null, string token = null, string authID = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetLegacyAuthorizationsAsyncWithHttpInfo(zapTraceSpan, userID, user, orgID, org, token, authID,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all legacy authorizations 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Authorizations)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Authorizations>> GetLegacyAuthorizationsAsyncWithHttpInfo(
            string zapTraceSpan = null, string userID = null, string user = null, string orgID = null,
            string org = null, string token = null, string authID = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetLegacyAuthorizationsAsyncWithIRestResponse(zapTraceSpan, userID, user, orgID, org, token,
                    authID, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List all legacy authorizations 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="userID">Only show legacy authorizations that belong to a user ID. (optional)</param>
        /// <param name="user">Only show legacy authorizations that belong to a user name. (optional)</param>
        /// <param name="orgID">Only show legacy authorizations that belong to an organization ID. (optional)</param>
        /// <param name="org">Only show legacy authorizations that belong to a organization name. (optional)</param>
        /// <param name="token">Only show legacy authorizations with a specified token (auth name). (optional)</param>
        /// <param name="authID">Only show legacy authorizations with a specified auth ID. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Authorizations)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetLegacyAuthorizationsAsyncWithIRestResponse(
            string zapTraceSpan = null, string userID = null, string user = null, string orgID = null,
            string org = null, string token = null, string authID = null, CancellationToken cancellationToken = default)
        {
            var localVarPath = "/private/legacy/authorizations";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (userID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "userID", userID)); // query parameter
            }

            if (user != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "user", user)); // query parameter
            }

            if (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // query parameter
            }

            if (org != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "org", org)); // query parameter
            }

            if (token != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "token", token)); // query parameter
            }

            if (authID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "authID", authID)); // query parameter
            }

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

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

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Authorization</returns>
        public Authorization GetLegacyAuthorizationsID(string authID, string zapTraceSpan = null)
        {
            var localVarResponse = GetLegacyAuthorizationsIDWithHttpInfo(authID, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        public ApiResponse<Authorization> GetLegacyAuthorizationsIDWithHttpInfo(string authID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->GetLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Retrieve a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Authorization</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetLegacyAuthorizationsIDWithIRestResponseAsync(
            string authID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->GetLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        public RestResponse GetLegacyAuthorizationsIDWithIRestResponse(string authID, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->GetLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        public RestRequest GetLegacyAuthorizationsIDWithRestRequest(string authID, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->GetLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// Retrieve a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Authorization</returns>
        public async System.Threading.Tasks.Task<Authorization> GetLegacyAuthorizationsIDAsync(string authID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetLegacyAuthorizationsIDAsyncWithHttpInfo(authID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Authorization)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Authorization>> GetLegacyAuthorizationsIDAsyncWithHttpInfo(
            string authID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetLegacyAuthorizationsIDAsyncWithIRestResponse(authID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Retrieve a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to get.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Authorization)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetLegacyAuthorizationsIDAsyncWithIRestResponse(
            string authID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->GetLegacyAuthorizationsID");
            }

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            // 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.Get, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a legacy authorization to be active or inactive 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Authorization</returns>
        public Authorization PatchLegacyAuthorizationsID(string authID,
            AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null)
        {
            var localVarResponse =
                PatchLegacyAuthorizationsIDWithHttpInfo(authID, authorizationUpdateRequest, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a legacy authorization to be active or inactive 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        public ApiResponse<Authorization> PatchLegacyAuthorizationsIDWithHttpInfo(string authID,
            AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PatchLegacyAuthorizationsID");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (authorizationUpdateRequest != null && authorizationUpdateRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(authorizationUpdateRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = authorizationUpdateRequest; // 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.Patch, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Update a legacy authorization to be active or inactive 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Authorization</returns>
        public async System.Threading.Tasks.Task<RestResponse> PatchLegacyAuthorizationsIDWithIRestResponseAsync(
            string authID, AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PatchLegacyAuthorizationsID");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (authorizationUpdateRequest != null && authorizationUpdateRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(authorizationUpdateRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = authorizationUpdateRequest; // 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.Patch, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a legacy authorization to be active or inactive 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        public RestResponse PatchLegacyAuthorizationsIDWithIRestResponse(string authID,
            AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PatchLegacyAuthorizationsID");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (authorizationUpdateRequest != null && authorizationUpdateRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(authorizationUpdateRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = authorizationUpdateRequest; // 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.Patch, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a legacy authorization to be active or inactive 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        public RestRequest PatchLegacyAuthorizationsIDWithRestRequest(string authID,
            AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PatchLegacyAuthorizationsID");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (authorizationUpdateRequest != null && authorizationUpdateRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(authorizationUpdateRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = authorizationUpdateRequest; // 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.Patch, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// Update a legacy authorization to be active or inactive 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Authorization</returns>
        public async System.Threading.Tasks.Task<Authorization> PatchLegacyAuthorizationsIDAsync(string authID,
            AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PatchLegacyAuthorizationsIDAsyncWithHttpInfo(authID, authorizationUpdateRequest, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a legacy authorization to be active or inactive 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Authorization)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Authorization>>
            PatchLegacyAuthorizationsIDAsyncWithHttpInfo(string authID,
                AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null,
                CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PatchLegacyAuthorizationsIDAsyncWithIRestResponse(authID, authorizationUpdateRequest,
                    zapTraceSpan, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Update a legacy authorization to be active or inactive 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="authorizationUpdateRequest">Legacy authorization to update</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Authorization)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PatchLegacyAuthorizationsIDAsyncWithIRestResponse(
            string authID, AuthorizationUpdateRequest authorizationUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PatchLegacyAuthorizationsID");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (authorizationUpdateRequest != null && authorizationUpdateRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(authorizationUpdateRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = authorizationUpdateRequest; // 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.Patch, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

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

            return localVarResponse;
        }

        /// <summary>
        /// Create a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Authorization</returns>
        public Authorization PostLegacyAuthorizations(LegacyAuthorizationPostRequest legacyAuthorizationPostRequest,
            string zapTraceSpan = null)
        {
            var localVarResponse = PostLegacyAuthorizationsWithHttpInfo(legacyAuthorizationPostRequest, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Create a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        public ApiResponse<Authorization> PostLegacyAuthorizationsWithHttpInfo(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'legacyAuthorizationPostRequest' is set
            if (legacyAuthorizationPostRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'legacyAuthorizationPostRequest' when calling LegacyAuthorizationsService->PostLegacyAuthorizations");
            }

            var localVarPath = "/private/legacy/authorizations";
            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 (legacyAuthorizationPostRequest != null && legacyAuthorizationPostRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(legacyAuthorizationPostRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = legacyAuthorizationPostRequest; // 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("PostLegacyAuthorizations", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Create a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Authorization</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostLegacyAuthorizationsWithIRestResponseAsync(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'legacyAuthorizationPostRequest' is set
            if (legacyAuthorizationPostRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'legacyAuthorizationPostRequest' when calling LegacyAuthorizationsService->PostLegacyAuthorizations");
            }

            var localVarPath = "/private/legacy/authorizations";
            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 (legacyAuthorizationPostRequest != null && legacyAuthorizationPostRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(legacyAuthorizationPostRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = legacyAuthorizationPostRequest; // 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("PostLegacyAuthorizations", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Create a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        public RestResponse PostLegacyAuthorizationsWithIRestResponse(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'legacyAuthorizationPostRequest' is set
            if (legacyAuthorizationPostRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'legacyAuthorizationPostRequest' when calling LegacyAuthorizationsService->PostLegacyAuthorizations");
            }

            var localVarPath = "/private/legacy/authorizations";
            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 (legacyAuthorizationPostRequest != null && legacyAuthorizationPostRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(legacyAuthorizationPostRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = legacyAuthorizationPostRequest; // 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("PostLegacyAuthorizations", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Create a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Authorization</returns>
        public RestRequest PostLegacyAuthorizationsWithRestRequest(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'legacyAuthorizationPostRequest' is set
            if (legacyAuthorizationPostRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'legacyAuthorizationPostRequest' when calling LegacyAuthorizationsService->PostLegacyAuthorizations");
            }

            var localVarPath = "/private/legacy/authorizations";
            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 (legacyAuthorizationPostRequest != null && legacyAuthorizationPostRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(legacyAuthorizationPostRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = legacyAuthorizationPostRequest; // 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 legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Authorization</returns>
        public async System.Threading.Tasks.Task<Authorization> PostLegacyAuthorizationsAsync(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostLegacyAuthorizationsAsyncWithHttpInfo(legacyAuthorizationPostRequest, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Create a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Authorization)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Authorization>> PostLegacyAuthorizationsAsyncWithHttpInfo(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostLegacyAuthorizationsAsyncWithIRestResponse(legacyAuthorizationPostRequest, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Create a legacy authorization 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="legacyAuthorizationPostRequest">Legacy authorization to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Authorization)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostLegacyAuthorizationsAsyncWithIRestResponse(
            LegacyAuthorizationPostRequest legacyAuthorizationPostRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'legacyAuthorizationPostRequest' is set
            if (legacyAuthorizationPostRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'legacyAuthorizationPostRequest' when calling LegacyAuthorizationsService->PostLegacyAuthorizations");
            }

            var localVarPath = "/private/legacy/authorizations";
            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 (legacyAuthorizationPostRequest != null && legacyAuthorizationPostRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(legacyAuthorizationPostRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = legacyAuthorizationPostRequest; // 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("PostLegacyAuthorizations", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Set a legacy authorization password 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void PostLegacyAuthorizationsIDPassword(string authID, PasswordResetBody passwordResetBody,
            string zapTraceSpan = null)
        {
            PostLegacyAuthorizationsIDPasswordWithHttpInfo(authID, passwordResetBody, zapTraceSpan);
        }

        /// <summary>
        /// Set a legacy authorization password 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> PostLegacyAuthorizationsIDPasswordWithHttpInfo(string authID,
            PasswordResetBody passwordResetBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PostLegacyAuthorizationsIDPassword");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}/password";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (passwordResetBody != null && passwordResetBody.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(passwordResetBody); // http body (model) parameter
            }
            else
            {
                localVarPostBody = passwordResetBody; // 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("PostLegacyAuthorizationsIDPassword", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Set a legacy authorization password 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostLegacyAuthorizationsIDPasswordWithIRestResponseAsync(
            string authID, PasswordResetBody passwordResetBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PostLegacyAuthorizationsIDPassword");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}/password";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (passwordResetBody != null && passwordResetBody.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(passwordResetBody); // http body (model) parameter
            }
            else
            {
                localVarPostBody = passwordResetBody; // 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("PostLegacyAuthorizationsIDPassword", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Set a legacy authorization password 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse PostLegacyAuthorizationsIDPasswordWithIRestResponse(string authID,
            PasswordResetBody passwordResetBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PostLegacyAuthorizationsIDPassword");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}/password";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (passwordResetBody != null && passwordResetBody.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(passwordResetBody); // http body (model) parameter
            }
            else
            {
                localVarPostBody = passwordResetBody; // 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("PostLegacyAuthorizationsIDPassword", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Set a legacy authorization password 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest PostLegacyAuthorizationsIDPasswordWithRestRequest(string authID,
            PasswordResetBody passwordResetBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PostLegacyAuthorizationsIDPassword");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}/password";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (passwordResetBody != null && passwordResetBody.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(passwordResetBody); // http body (model) parameter
            }
            else
            {
                localVarPostBody = passwordResetBody; // 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>
        /// Set a legacy authorization password 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        public System.Threading.Tasks.Task PostLegacyAuthorizationsIDPasswordAsync(string authID,
            PasswordResetBody passwordResetBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            return PostLegacyAuthorizationsIDPasswordAsyncWithHttpInfo(authID, passwordResetBody, zapTraceSpan,
                cancellationToken);
        }

        /// <summary>
        /// Set a legacy authorization password 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        public async System.Threading.Tasks.Task<ApiResponse<object>>
            PostLegacyAuthorizationsIDPasswordAsyncWithHttpInfo(string authID, PasswordResetBody passwordResetBody,
                string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostLegacyAuthorizationsIDPasswordAsyncWithIRestResponse(authID, passwordResetBody, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Set a legacy authorization password 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="authID">The ID of the legacy authorization to update.</param>
        /// <param name="passwordResetBody">New password</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostLegacyAuthorizationsIDPasswordAsyncWithIRestResponse(
            string authID, PasswordResetBody passwordResetBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'authID' is set
            if (authID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'authID' when calling LegacyAuthorizationsService->PostLegacyAuthorizationsIDPassword");
            }

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

            var localVarPath = "/private/legacy/authorizations/{authID}/password";
            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 (authID != null)
            {
                localVarPathParams.Add("authID", Configuration.ApiClient.ParameterToString(authID)); // path parameter
            }

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

            if (passwordResetBody != null && passwordResetBody.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(passwordResetBody); // http body (model) parameter
            }
            else
            {
                localVarPostBody = passwordResetBody; // 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("PostLegacyAuthorizationsIDPassword", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }
    }
}