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

        /// <summary>
        /// Delete a task
        /// </summary>
        /// <remarks>
        /// Deletes a task and all associated records
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        void DeleteTasksID(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// Delete a task
        /// </summary>
        /// <remarks>
        /// Deletes a task and all associated records
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> DeleteTasksIDWithHttpInfo(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// Delete a label from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelID">The label ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        void DeleteTasksIDLabelsID(string taskID, string labelID, string zapTraceSpan = null);

        /// <summary>
        /// Delete a label from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelID">The label ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object>
            DeleteTasksIDLabelsIDWithHttpInfo(string taskID, string labelID, string zapTraceSpan = null);

        /// <summary>
        /// Remove a member from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        void DeleteTasksIDMembersID(string userID, string taskID, string zapTraceSpan = null);

        /// <summary>
        /// Remove a member from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object>
            DeleteTasksIDMembersIDWithHttpInfo(string userID, string taskID, string zapTraceSpan = null);

        /// <summary>
        /// Remove an owner from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        void DeleteTasksIDOwnersID(string userID, string taskID, string zapTraceSpan = null);

        /// <summary>
        /// Remove an owner from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> DeleteTasksIDOwnersIDWithHttpInfo(string userID, string taskID, string zapTraceSpan = null);

        /// <summary>
        /// Cancel a running task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        void DeleteTasksIDRunsID(string taskID, string runID, string zapTraceSpan = null);

        /// <summary>
        /// Cancel a running task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> DeleteTasksIDRunsIDWithHttpInfo(string taskID, string runID, string zapTraceSpan = null);

        /// <summary>
        /// List all tasks
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <returns>Tasks</returns>
        Tasks GetTasks(string zapTraceSpan = null, string name = null, string after = null, string user = null,
            string org = null, string orgID = null, string status = null, int? limit = null, string type = null);

        /// <summary>
        /// List all tasks
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <returns>ApiResponse of Tasks</returns>
        ApiResponse<Tasks> GetTasksWithHttpInfo(string zapTraceSpan = null, string name = null, string after = null,
            string user = null, string org = null, string orgID = null, string status = null, int? limit = null,
            string type = null);

        /// <summary>
        /// Retrieve a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>TaskType</returns>
        TaskType GetTasksID(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// Retrieve a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of TaskType</returns>
        ApiResponse<TaskType> GetTasksIDWithHttpInfo(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// List all labels for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>LabelsResponse</returns>
        LabelsResponse GetTasksIDLabels(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// List all labels for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of LabelsResponse</returns>
        ApiResponse<LabelsResponse> GetTasksIDLabelsWithHttpInfo(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// Retrieve all logs for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Logs</returns>
        Logs GetTasksIDLogs(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// Retrieve all logs for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Logs</returns>
        ApiResponse<Logs> GetTasksIDLogsWithHttpInfo(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// List all task members
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceMembers</returns>
        ResourceMembers GetTasksIDMembers(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// List all task members
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMembers</returns>
        ApiResponse<ResourceMembers> GetTasksIDMembersWithHttpInfo(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// List all owners of a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceOwners</returns>
        ResourceOwners GetTasksIDOwners(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// List all owners of a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceOwners</returns>
        ApiResponse<ResourceOwners> GetTasksIDOwnersWithHttpInfo(string taskID, string zapTraceSpan = null);

        /// <summary>
        /// List runs for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <returns>Runs</returns>
        Runs GetTasksIDRuns(string taskID, string zapTraceSpan = null, string after = null, int? limit = null,
            DateTime? afterTime = null, DateTime? beforeTime = null);

        /// <summary>
        /// List runs for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <returns>ApiResponse of Runs</returns>
        ApiResponse<Runs> GetTasksIDRunsWithHttpInfo(string taskID, string zapTraceSpan = null, string after = null,
            int? limit = null, DateTime? afterTime = null, DateTime? beforeTime = null);

        /// <summary>
        /// Retrieve a single run for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Run</returns>
        Run GetTasksIDRunsID(string taskID, string runID, string zapTraceSpan = null);

        /// <summary>
        /// Retrieve a single run for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        ApiResponse<Run> GetTasksIDRunsIDWithHttpInfo(string taskID, string runID, string zapTraceSpan = null);

        /// <summary>
        /// Retrieve all logs for a run
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Logs</returns>
        Logs GetTasksIDRunsIDLogs(string taskID, string runID, string zapTraceSpan = null);

        /// <summary>
        /// Retrieve all logs for a run
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Logs</returns>
        ApiResponse<Logs> GetTasksIDRunsIDLogsWithHttpInfo(string taskID, string runID, string zapTraceSpan = null);

        /// <summary>
        /// Update a task
        /// </summary>
        /// <remarks>
        /// Update a task. This will cancel all queued runs.
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>TaskType</returns>
        TaskType PatchTasksID(string taskID, TaskUpdateRequest taskUpdateRequest, string zapTraceSpan = null);

        /// <summary>
        /// Update a task
        /// </summary>
        /// <remarks>
        /// Update a task. This will cancel all queued runs.
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of TaskType</returns>
        ApiResponse<TaskType> PatchTasksIDWithHttpInfo(string taskID, TaskUpdateRequest taskUpdateRequest,
            string zapTraceSpan = null);

        /// <summary>
        /// Create a new task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>TaskType</returns>
        TaskType PostTasks(TaskCreateRequest taskCreateRequest, string zapTraceSpan = null);

        /// <summary>
        /// Create a new task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of TaskType</returns>
        ApiResponse<TaskType> PostTasksWithHttpInfo(TaskCreateRequest taskCreateRequest, string zapTraceSpan = null);

        /// <summary>
        /// Add a label to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>LabelResponse</returns>
        LabelResponse PostTasksIDLabels(string taskID, LabelMapping labelMapping, string zapTraceSpan = null);

        /// <summary>
        /// Add a label to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of LabelResponse</returns>
        ApiResponse<LabelResponse> PostTasksIDLabelsWithHttpInfo(string taskID, LabelMapping labelMapping,
            string zapTraceSpan = null);

        /// <summary>
        /// Add a member to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceMember</returns>
        ResourceMember PostTasksIDMembers(string taskID, AddResourceMemberRequestBody addResourceMemberRequestBody,
            string zapTraceSpan = null);

        /// <summary>
        /// Add a member to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMember</returns>
        ApiResponse<ResourceMember> PostTasksIDMembersWithHttpInfo(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null);

        /// <summary>
        /// Add an owner to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceOwner</returns>
        ResourceOwner PostTasksIDOwners(string taskID, AddResourceMemberRequestBody addResourceMemberRequestBody,
            string zapTraceSpan = null);

        /// <summary>
        /// Add an owner to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceOwner</returns>
        ApiResponse<ResourceOwner> PostTasksIDOwnersWithHttpInfo(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null);

        /// <summary>
        /// Manually start a task run, overriding the current schedule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <returns>Run</returns>
        Run PostTasksIDRuns(string taskID, string zapTraceSpan = null, RunManually runManually = null);

        /// <summary>
        /// Manually start a task run, overriding the current schedule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        ApiResponse<Run> PostTasksIDRunsWithHttpInfo(string taskID, string zapTraceSpan = null,
            RunManually runManually = null);

        /// <summary>
        /// Retry a task run
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <returns>Run</returns>
        Run PostTasksIDRunsIDRetry(string taskID, string runID, string zapTraceSpan = null, string body = null);

        /// <summary>
        /// Retry a task run
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        ApiResponse<Run> PostTasksIDRunsIDRetryWithHttpInfo(string taskID, string runID, string zapTraceSpan = null,
            string body = null);

        #endregion Synchronous Operations

        #region Asynchronous Operations

        /// <summary>
        /// Delete a task
        /// </summary>
        /// <remarks>
        /// Deletes a task and all associated records
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task 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 DeleteTasksIDAsync(string taskID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Delete a task
        /// </summary>
        /// <remarks>
        /// Deletes a task and all associated records
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task 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>> DeleteTasksIDAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

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

        /// <summary>
        /// Delete a label from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelID">The label ID.</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>> DeleteTasksIDLabelsIDAsyncWithHttpInfo(string taskID,
            string labelID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Remove a member from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        System.Threading.Tasks.Task DeleteTasksIDMembersIDAsync(string userID, string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Remove a member from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</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>> DeleteTasksIDMembersIDAsyncWithHttpInfo(string userID,
            string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Remove an owner from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        System.Threading.Tasks.Task DeleteTasksIDOwnersIDAsync(string userID, string taskID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Remove an owner from a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</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>> DeleteTasksIDOwnersIDAsyncWithHttpInfo(string userID,
            string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Cancel a running task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        System.Threading.Tasks.Task DeleteTasksIDRunsIDAsync(string taskID, string runID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Cancel a running task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</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>> DeleteTasksIDRunsIDAsyncWithHttpInfo(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all tasks
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Tasks</returns>
        System.Threading.Tasks.Task<Tasks> GetTasksAsync(string zapTraceSpan = null, string name = null,
            string after = null, string user = null, string org = null, string orgID = null, string status = null,
            int? limit = null, string type = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all tasks
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Tasks)</returns>
        System.Threading.Tasks.Task<ApiResponse<Tasks>> GetTasksAsyncWithHttpInfo(string zapTraceSpan = null,
            string name = null, string after = null, string user = null, string org = null, string orgID = null,
            string status = null, int? limit = null, string type = null, CancellationToken cancellationToken = default);

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

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

        /// <summary>
        /// List all labels for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of LabelsResponse</returns>
        System.Threading.Tasks.Task<LabelsResponse> GetTasksIDLabelsAsync(string taskID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// List all labels for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (LabelsResponse)</returns>
        System.Threading.Tasks.Task<ApiResponse<LabelsResponse>> GetTasksIDLabelsAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve all logs for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Logs</returns>
        System.Threading.Tasks.Task<Logs> GetTasksIDLogsAsync(string taskID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve all logs for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Logs)</returns>
        System.Threading.Tasks.Task<ApiResponse<Logs>> GetTasksIDLogsAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all task members
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ResourceMembers</returns>
        System.Threading.Tasks.Task<ResourceMembers> GetTasksIDMembersAsync(string taskID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// List all task members
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ResourceMembers)</returns>
        System.Threading.Tasks.Task<ApiResponse<ResourceMembers>> GetTasksIDMembersAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all owners of a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ResourceOwners</returns>
        System.Threading.Tasks.Task<ResourceOwners> GetTasksIDOwnersAsync(string taskID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// List all owners of a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ResourceOwners)</returns>
        System.Threading.Tasks.Task<ApiResponse<ResourceOwners>> GetTasksIDOwnersAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List runs for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Runs</returns>
        System.Threading.Tasks.Task<Runs> GetTasksIDRunsAsync(string taskID, string zapTraceSpan = null,
            string after = null, int? limit = null, DateTime? afterTime = null, DateTime? beforeTime = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// List runs for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Runs)</returns>
        System.Threading.Tasks.Task<ApiResponse<Runs>> GetTasksIDRunsAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, string after = null, int? limit = null, DateTime? afterTime = null,
            DateTime? beforeTime = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve a single run for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Run</returns>
        System.Threading.Tasks.Task<Run> GetTasksIDRunsIDAsync(string taskID, string runID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve a single run for a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Run)</returns>
        System.Threading.Tasks.Task<ApiResponse<Run>> GetTasksIDRunsIDAsyncWithHttpInfo(string taskID, string runID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve all logs for a run
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Logs</returns>
        System.Threading.Tasks.Task<Logs> GetTasksIDRunsIDLogsAsync(string taskID, string runID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve all logs for a run
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Logs)</returns>
        System.Threading.Tasks.Task<ApiResponse<Logs>> GetTasksIDRunsIDLogsAsyncWithHttpInfo(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a task
        /// </summary>
        /// <remarks>
        /// Update a task. This will cancel all queued runs.
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of TaskType</returns>
        System.Threading.Tasks.Task<TaskType> PatchTasksIDAsync(string taskID, TaskUpdateRequest taskUpdateRequest,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a task
        /// </summary>
        /// <remarks>
        /// Update a task. This will cancel all queued runs.
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (TaskType)</returns>
        System.Threading.Tasks.Task<ApiResponse<TaskType>> PatchTasksIDAsyncWithHttpInfo(string taskID,
            TaskUpdateRequest taskUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Create a new task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of TaskType</returns>
        System.Threading.Tasks.Task<TaskType> PostTasksAsync(TaskCreateRequest taskCreateRequest,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Create a new task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (TaskType)</returns>
        System.Threading.Tasks.Task<ApiResponse<TaskType>> PostTasksAsyncWithHttpInfo(
            TaskCreateRequest taskCreateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Add a label to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of LabelResponse</returns>
        System.Threading.Tasks.Task<LabelResponse> PostTasksIDLabelsAsync(string taskID, LabelMapping labelMapping,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Add a label to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (LabelResponse)</returns>
        System.Threading.Tasks.Task<ApiResponse<LabelResponse>> PostTasksIDLabelsAsyncWithHttpInfo(string taskID,
            LabelMapping labelMapping, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Add a member to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ResourceMember</returns>
        System.Threading.Tasks.Task<ResourceMember> PostTasksIDMembersAsync(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Add a member to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ResourceMember)</returns>
        System.Threading.Tasks.Task<ApiResponse<ResourceMember>> PostTasksIDMembersAsyncWithHttpInfo(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Add an owner to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ResourceOwner</returns>
        System.Threading.Tasks.Task<ResourceOwner> PostTasksIDOwnersAsync(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Add an owner to a task
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ResourceOwner)</returns>
        System.Threading.Tasks.Task<ApiResponse<ResourceOwner>> PostTasksIDOwnersAsyncWithHttpInfo(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Manually start a task run, overriding the current schedule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Run</returns>
        System.Threading.Tasks.Task<Run> PostTasksIDRunsAsync(string taskID, string zapTraceSpan = null,
            RunManually runManually = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Manually start a task run, overriding the current schedule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Run)</returns>
        System.Threading.Tasks.Task<ApiResponse<Run>> PostTasksIDRunsAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, RunManually runManually = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Retry a task run
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Run</returns>
        System.Threading.Tasks.Task<Run> PostTasksIDRunsIDRetryAsync(string taskID, string runID,
            string zapTraceSpan = null, string body = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Retry a task run
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Run)</returns>
        System.Threading.Tasks.Task<ApiResponse<Run>> PostTasksIDRunsIDRetryAsyncWithHttpInfo(string taskID,
            string runID, string zapTraceSpan = null, string body = null,
            CancellationToken cancellationToken = default);

        #endregion Asynchronous Operations
    }

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

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

            ExceptionFactory = Configuration.DefaultExceptionFactory;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="TasksService"/> class
        /// using Configuration object
        /// </summary>
        /// <param name="configuration">An instance of Configuration</param>
        /// <returns></returns>
        public TasksService(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 task Deletes a task and all associated records
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteTasksID(string taskID, string zapTraceSpan = null)
        {
            DeleteTasksIDWithHttpInfo(taskID, zapTraceSpan);
        }

        /// <summary>
        /// Delete a task Deletes a task and all associated records
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> DeleteTasksIDWithHttpInfo(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksID");
            }

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Delete a task Deletes a task and all associated records
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task 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> DeleteTasksIDWithIRestResponseAsync(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksID");
            }

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Delete a task Deletes a task and all associated records
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse DeleteTasksIDWithIRestResponse(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksID");
            }

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Delete a task Deletes a task and all associated records
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest DeleteTasksIDWithRestRequest(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksID");
            }

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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 task Deletes a task and all associated records
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task 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 DeleteTasksIDAsync(string taskID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            return DeleteTasksIDAsyncWithHttpInfo(taskID, zapTraceSpan, cancellationToken);
        }

        /// <summary>
        /// Delete a task Deletes a task and all associated records
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task 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>> DeleteTasksIDAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await DeleteTasksIDAsyncWithIRestResponse(taskID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Delete a task Deletes a task and all associated records
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task 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> DeleteTasksIDAsyncWithIRestResponse(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksID");
            }

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Delete a label from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelID">The label ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteTasksIDLabelsID(string taskID, string labelID, string zapTraceSpan = null)
        {
            DeleteTasksIDLabelsIDWithHttpInfo(taskID, labelID, zapTraceSpan);
        }

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

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels/{labelID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (labelID != null)
            {
                localVarPathParams.Add("labelID", Configuration.ApiClient.ParameterToString(labelID)); // 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("DeleteTasksIDLabelsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Delete a label from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelID">The label ID.</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> DeleteTasksIDLabelsIDWithIRestResponseAsync(
            string taskID, string labelID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksIDLabelsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels/{labelID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (labelID != null)
            {
                localVarPathParams.Add("labelID", Configuration.ApiClient.ParameterToString(labelID)); // 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("DeleteTasksIDLabelsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels/{labelID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (labelID != null)
            {
                localVarPathParams.Add("labelID", Configuration.ApiClient.ParameterToString(labelID)); // 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("DeleteTasksIDLabelsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels/{labelID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (labelID != null)
            {
                localVarPathParams.Add("labelID", Configuration.ApiClient.ParameterToString(labelID)); // 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 label from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelID">The label ID.</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 DeleteTasksIDLabelsIDAsync(string taskID, string labelID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            return DeleteTasksIDLabelsIDAsyncWithHttpInfo(taskID, labelID, zapTraceSpan, cancellationToken);
        }

        /// <summary>
        /// Delete a label from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelID">The label ID.</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>> DeleteTasksIDLabelsIDAsyncWithHttpInfo(
            string taskID, string labelID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await DeleteTasksIDLabelsIDAsyncWithIRestResponse(taskID, labelID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Delete a label from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelID">The label ID.</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> DeleteTasksIDLabelsIDAsyncWithIRestResponse(
            string taskID, string labelID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksIDLabelsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels/{labelID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (labelID != null)
            {
                localVarPathParams.Add("labelID", Configuration.ApiClient.ParameterToString(labelID)); // 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("DeleteTasksIDLabelsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Remove a member from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteTasksIDMembersID(string userID, string taskID, string zapTraceSpan = null)
        {
            DeleteTasksIDMembersIDWithHttpInfo(userID, taskID, zapTraceSpan);
        }

        /// <summary>
        /// Remove a member from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> DeleteTasksIDMembersIDWithHttpInfo(string userID, string taskID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDMembersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksIDMembersID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Remove a member from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</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> DeleteTasksIDMembersIDWithIRestResponseAsync(
            string userID, string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDMembersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksIDMembersID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Remove a member from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse DeleteTasksIDMembersIDWithIRestResponse(string userID, string taskID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDMembersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksIDMembersID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Remove a member from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest DeleteTasksIDMembersIDWithRestRequest(string userID, string taskID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDMembersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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>
        /// Remove a member from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</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 DeleteTasksIDMembersIDAsync(string userID, string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            return DeleteTasksIDMembersIDAsyncWithHttpInfo(userID, taskID, zapTraceSpan, cancellationToken);
        }

        /// <summary>
        /// Remove a member from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</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>> DeleteTasksIDMembersIDAsyncWithHttpInfo(
            string userID, string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await DeleteTasksIDMembersIDAsyncWithIRestResponse(userID, taskID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Remove a member from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the member to remove.</param>
        /// <param name="taskID">The task ID.</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> DeleteTasksIDMembersIDAsyncWithIRestResponse(
            string userID, string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDMembersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksIDMembersID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Remove an owner from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteTasksIDOwnersID(string userID, string taskID, string zapTraceSpan = null)
        {
            DeleteTasksIDOwnersIDWithHttpInfo(userID, taskID, zapTraceSpan);
        }

        /// <summary>
        /// Remove an owner from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> DeleteTasksIDOwnersIDWithHttpInfo(string userID, string taskID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDOwnersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksIDOwnersID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Remove an owner from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</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> DeleteTasksIDOwnersIDWithIRestResponseAsync(
            string userID, string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDOwnersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksIDOwnersID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Remove an owner from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse DeleteTasksIDOwnersIDWithIRestResponse(string userID, string taskID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDOwnersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksIDOwnersID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Remove an owner from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest DeleteTasksIDOwnersIDWithRestRequest(string userID, string taskID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDOwnersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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>
        /// Remove an owner from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</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 DeleteTasksIDOwnersIDAsync(string userID, string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            return DeleteTasksIDOwnersIDAsyncWithHttpInfo(userID, taskID, zapTraceSpan, cancellationToken);
        }

        /// <summary>
        /// Remove an owner from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</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>> DeleteTasksIDOwnersIDAsyncWithHttpInfo(
            string userID, string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await DeleteTasksIDOwnersIDAsyncWithIRestResponse(userID, taskID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Remove an owner from a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="userID">The ID of the owner to remove.</param>
        /// <param name="taskID">The task ID.</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> DeleteTasksIDOwnersIDAsyncWithIRestResponse(
            string userID, string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TasksService->DeleteTasksIDOwnersID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners/{userID}";
            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)
            {
                localVarPathParams.Add("userID", Configuration.ApiClient.ParameterToString(userID)); // path parameter
            }

            if (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("DeleteTasksIDOwnersID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Cancel a running task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteTasksIDRunsID(string taskID, string runID, string zapTraceSpan = null)
        {
            DeleteTasksIDRunsIDWithHttpInfo(taskID, runID, zapTraceSpan);
        }

        /// <summary>
        /// Cancel a running task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> DeleteTasksIDRunsIDWithHttpInfo(string taskID, string runID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("DeleteTasksIDRunsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Cancel a running task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</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> DeleteTasksIDRunsIDWithIRestResponseAsync(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("DeleteTasksIDRunsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Cancel a running task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse DeleteTasksIDRunsIDWithIRestResponse(string taskID, string runID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("DeleteTasksIDRunsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Cancel a running task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest DeleteTasksIDRunsIDWithRestRequest(string taskID, string runID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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>
        /// Cancel a running task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</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 DeleteTasksIDRunsIDAsync(string taskID, string runID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            return DeleteTasksIDRunsIDAsyncWithHttpInfo(taskID, runID, zapTraceSpan, cancellationToken);
        }

        /// <summary>
        /// Cancel a running task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</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>> DeleteTasksIDRunsIDAsyncWithHttpInfo(
            string taskID, string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await DeleteTasksIDRunsIDAsyncWithIRestResponse(taskID, runID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Cancel a running task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</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> DeleteTasksIDRunsIDAsyncWithIRestResponse(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->DeleteTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("DeleteTasksIDRunsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all tasks 
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <returns>Tasks</returns>
        public Tasks GetTasks(string zapTraceSpan = null, string name = null, string after = null, string user = null,
            string org = null, string orgID = null, string status = null, int? limit = null, string type = null)
        {
            var localVarResponse =
                GetTasksWithHttpInfo(zapTraceSpan, name, after, user, org, orgID, status, limit, type);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all tasks 
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <returns>ApiResponse of Tasks</returns>
        public ApiResponse<Tasks> GetTasksWithHttpInfo(string zapTraceSpan = null, string name = null,
            string after = null, string user = null, string org = null, string orgID = null, string status = null,
            int? limit = null, string type = null)
        {
            var localVarPath = "/api/v2/tasks";
            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 (name != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "name", name)); // query parameter
            }

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

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

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

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

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

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

            if (type != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "type", type)); // 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("GetTasks", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// List all tasks 
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Tasks</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksWithIRestResponseAsync(
            string zapTraceSpan = null, string name = null, string after = null, string user = null, string org = null,
            string orgID = null, string status = null, int? limit = null, string type = null,
            CancellationToken cancellationToken = default)
        {
            var localVarPath = "/api/v2/tasks";
            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 (name != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "name", name)); // query parameter
            }

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

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

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

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

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

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

            if (type != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "type", type)); // 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("GetTasks", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all tasks 
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <returns>ApiResponse of Tasks</returns>
        public RestResponse GetTasksWithIRestResponse(string zapTraceSpan = null, string name = null,
            string after = null, string user = null, string org = null, string orgID = null, string status = null,
            int? limit = null, string type = null)
        {
            var localVarPath = "/api/v2/tasks";
            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 (name != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "name", name)); // query parameter
            }

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

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

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

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

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

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

            if (type != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "type", type)); // 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("GetTasks", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all tasks 
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <returns>ApiResponse of Tasks</returns>
        public RestRequest GetTasksWithRestRequest(string zapTraceSpan = null, string name = null, string after = null,
            string user = null, string org = null, string orgID = null, string status = null, int? limit = null,
            string type = null)
        {
            var localVarPath = "/api/v2/tasks";
            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 (name != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "name", name)); // query parameter
            }

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

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

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

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

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

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

            if (type != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "type", type)); // 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 tasks 
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Tasks</returns>
        public async System.Threading.Tasks.Task<Tasks> GetTasksAsync(string zapTraceSpan = null, string name = null,
            string after = null, string user = null, string org = null, string orgID = null, string status = null,
            int? limit = null, string type = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetTasksAsyncWithHttpInfo(zapTraceSpan, name, after, user, org, orgID, status, limit, type,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all tasks 
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Tasks)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Tasks>> GetTasksAsyncWithHttpInfo(
            string zapTraceSpan = null, string name = null, string after = null, string user = null, string org = null,
            string orgID = null, string status = null, int? limit = null, string type = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await GetTasksAsyncWithIRestResponse(zapTraceSpan, name, after, user, org, orgID,
                status, limit, type, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List all tasks 
        /// </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="name">Returns task with a specific name. (optional)</param>
        /// <param name="after">Return tasks after a specified ID. (optional)</param>
        /// <param name="user">Filter tasks to a specific user ID. (optional)</param>
        /// <param name="org">Filter tasks to a specific organization name. (optional)</param>
        /// <param name="orgID">Filter tasks to a specific organization ID. (optional)</param>
        /// <param name="status">Filter tasks by a status- -\&quot;inactive\&quot; or \&quot;active\&quot;. (optional)</param>
        /// <param name="limit">The number of tasks to return (optional, default to 100)</param>
        /// <param name="type">Type of task, unset by default. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Tasks)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksAsyncWithIRestResponse(
            string zapTraceSpan = null, string name = null, string after = null, string user = null, string org = null,
            string orgID = null, string status = null, int? limit = null, string type = null,
            CancellationToken cancellationToken = default)
        {
            var localVarPath = "/api/v2/tasks";
            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 (name != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "name", name)); // query parameter
            }

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

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

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

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

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

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

            if (type != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "type", type)); // 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("GetTasks", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>TaskType</returns>
        public TaskType GetTasksID(string taskID, string zapTraceSpan = null)
        {
            var localVarResponse = GetTasksIDWithHttpInfo(taskID, zapTraceSpan);
            return localVarResponse.Data;
        }

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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 task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of TaskType</returns>
        public async System.Threading.Tasks.Task<TaskType> GetTasksIDAsync(string taskID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse = await GetTasksIDAsyncWithHttpInfo(taskID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all labels for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>LabelsResponse</returns>
        public LabelsResponse GetTasksIDLabels(string taskID, string zapTraceSpan = null)
        {
            var localVarResponse = GetTasksIDLabelsWithHttpInfo(taskID, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all labels for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of LabelsResponse</returns>
        public ApiResponse<LabelsResponse> GetTasksIDLabelsWithHttpInfo(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDLabels");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDLabels", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// List all labels for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of LabelsResponse</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDLabelsWithIRestResponseAsync(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDLabels");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDLabels", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all labels for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of LabelsResponse</returns>
        public RestResponse GetTasksIDLabelsWithIRestResponse(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDLabels");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDLabels", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all labels for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of LabelsResponse</returns>
        public RestRequest GetTasksIDLabelsWithRestRequest(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDLabels");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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>
        /// List all labels for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of LabelsResponse</returns>
        public async System.Threading.Tasks.Task<LabelsResponse> GetTasksIDLabelsAsync(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await GetTasksIDLabelsAsyncWithHttpInfo(taskID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all labels for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (LabelsResponse)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<LabelsResponse>> GetTasksIDLabelsAsyncWithHttpInfo(
            string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await GetTasksIDLabelsAsyncWithIRestResponse(taskID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List all labels for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (LabelsResponse)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDLabelsAsyncWithIRestResponse(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDLabels");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDLabels", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve all logs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Logs</returns>
        public Logs GetTasksIDLogs(string taskID, string zapTraceSpan = null)
        {
            var localVarResponse = GetTasksIDLogsWithHttpInfo(taskID, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve all logs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Logs</returns>
        public ApiResponse<Logs> GetTasksIDLogsWithHttpInfo(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDLogs");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDLogs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

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

            var localVarPath = "/api/v2/tasks/{taskID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDLogs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve all logs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Logs</returns>
        public RestResponse GetTasksIDLogsWithIRestResponse(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDLogs");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDLogs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve all logs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Logs</returns>
        public RestRequest GetTasksIDLogsWithRestRequest(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDLogs");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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 all logs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Logs</returns>
        public async System.Threading.Tasks.Task<Logs> GetTasksIDLogsAsync(string taskID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse = await GetTasksIDLogsAsyncWithHttpInfo(taskID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Retrieve all logs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Logs)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDLogsAsyncWithIRestResponse(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDLogs");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDLogs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all task members 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceMembers</returns>
        public ResourceMembers GetTasksIDMembers(string taskID, string zapTraceSpan = null)
        {
            var localVarResponse = GetTasksIDMembersWithHttpInfo(taskID, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all task members 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMembers</returns>
        public ApiResponse<ResourceMembers> GetTasksIDMembersWithHttpInfo(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDMembers");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDMembers", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// List all task members 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of ResourceMembers</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDMembersWithIRestResponseAsync(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDMembers");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDMembers", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all task members 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMembers</returns>
        public RestResponse GetTasksIDMembersWithIRestResponse(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDMembers");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDMembers", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all task members 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMembers</returns>
        public RestRequest GetTasksIDMembersWithRestRequest(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDMembers");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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>
        /// List all task members 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ResourceMembers</returns>
        public async System.Threading.Tasks.Task<ResourceMembers> GetTasksIDMembersAsync(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await GetTasksIDMembersAsyncWithHttpInfo(taskID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all task members 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ResourceMembers)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<ResourceMembers>> GetTasksIDMembersAsyncWithHttpInfo(
            string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetTasksIDMembersAsyncWithIRestResponse(taskID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List all task members 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (ResourceMembers)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDMembersAsyncWithIRestResponse(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDMembers");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDMembers", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all owners of a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceOwners</returns>
        public ResourceOwners GetTasksIDOwners(string taskID, string zapTraceSpan = null)
        {
            var localVarResponse = GetTasksIDOwnersWithHttpInfo(taskID, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all owners of a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceOwners</returns>
        public ApiResponse<ResourceOwners> GetTasksIDOwnersWithHttpInfo(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDOwners");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDOwners", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// List all owners of a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of ResourceOwners</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDOwnersWithIRestResponseAsync(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDOwners");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDOwners", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all owners of a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceOwners</returns>
        public RestResponse GetTasksIDOwnersWithIRestResponse(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDOwners");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDOwners", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all owners of a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceOwners</returns>
        public RestRequest GetTasksIDOwnersWithRestRequest(string taskID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDOwners");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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>
        /// List all owners of a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ResourceOwners</returns>
        public async System.Threading.Tasks.Task<ResourceOwners> GetTasksIDOwnersAsync(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await GetTasksIDOwnersAsyncWithHttpInfo(taskID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all owners of a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ResourceOwners)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<ResourceOwners>> GetTasksIDOwnersAsyncWithHttpInfo(
            string taskID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await GetTasksIDOwnersAsyncWithIRestResponse(taskID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List all owners of a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (ResourceOwners)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDOwnersAsyncWithIRestResponse(string taskID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDOwners");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // 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("GetTasksIDOwners", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List runs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <returns>Runs</returns>
        public Runs GetTasksIDRuns(string taskID, string zapTraceSpan = null, string after = null, int? limit = null,
            DateTime? afterTime = null, DateTime? beforeTime = null)
        {
            var localVarResponse =
                GetTasksIDRunsWithHttpInfo(taskID, zapTraceSpan, after, limit, afterTime, beforeTime);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List runs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <returns>ApiResponse of Runs</returns>
        public ApiResponse<Runs> GetTasksIDRunsWithHttpInfo(string taskID, string zapTraceSpan = null,
            string after = null, int? limit = null, DateTime? afterTime = null, DateTime? beforeTime = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

            if (beforeTime != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "beforeTime", beforeTime)); // 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("GetTasksIDRuns", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// List runs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Runs</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDRunsWithIRestResponseAsync(string taskID,
            string zapTraceSpan = null, string after = null, int? limit = null, DateTime? afterTime = null,
            DateTime? beforeTime = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

            if (beforeTime != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "beforeTime", beforeTime)); // 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("GetTasksIDRuns", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List runs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <returns>ApiResponse of Runs</returns>
        public RestResponse GetTasksIDRunsWithIRestResponse(string taskID, string zapTraceSpan = null,
            string after = null, int? limit = null, DateTime? afterTime = null, DateTime? beforeTime = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

            if (beforeTime != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "beforeTime", beforeTime)); // 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("GetTasksIDRuns", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List runs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <returns>ApiResponse of Runs</returns>
        public RestRequest GetTasksIDRunsWithRestRequest(string taskID, string zapTraceSpan = null, string after = null,
            int? limit = null, DateTime? afterTime = null, DateTime? beforeTime = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

            if (beforeTime != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "beforeTime", beforeTime)); // 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 runs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Runs</returns>
        public async System.Threading.Tasks.Task<Runs> GetTasksIDRunsAsync(string taskID, string zapTraceSpan = null,
            string after = null, int? limit = null, DateTime? afterTime = null, DateTime? beforeTime = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetTasksIDRunsAsyncWithHttpInfo(taskID, zapTraceSpan, after, limit, afterTime, beforeTime,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List runs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Runs)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Runs>> GetTasksIDRunsAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, string after = null, int? limit = null, DateTime? afterTime = null,
            DateTime? beforeTime = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetTasksIDRunsAsyncWithIRestResponse(taskID, zapTraceSpan, after, limit, afterTime, beforeTime,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List runs for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The ID of the task to get runs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="after">Returns runs after a specific ID. (optional)</param>
        /// <param name="limit">The number of runs to return (optional, default to 100)</param>
        /// <param name="afterTime">Filter runs to those scheduled after this time, RFC3339 (optional)</param>
        /// <param name="beforeTime">Filter runs to those scheduled before this time, RFC3339 (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Runs)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDRunsAsyncWithIRestResponse(string taskID,
            string zapTraceSpan = null, string after = null, int? limit = null, DateTime? afterTime = null,
            DateTime? beforeTime = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

            if (beforeTime != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "beforeTime", beforeTime)); // 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("GetTasksIDRuns", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a single run for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Run</returns>
        public Run GetTasksIDRunsID(string taskID, string runID, string zapTraceSpan = null)
        {
            var localVarResponse = GetTasksIDRunsIDWithHttpInfo(taskID, runID, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve a single run for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        public ApiResponse<Run> GetTasksIDRunsIDWithHttpInfo(string taskID, string runID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("GetTasksIDRunsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Retrieve a single run for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Run</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDRunsIDWithIRestResponseAsync(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("GetTasksIDRunsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a single run for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        public RestResponse GetTasksIDRunsIDWithIRestResponse(string taskID, string runID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("GetTasksIDRunsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a single run for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        public RestRequest GetTasksIDRunsIDWithRestRequest(string taskID, string runID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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 single run for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Run</returns>
        public async System.Threading.Tasks.Task<Run> GetTasksIDRunsIDAsync(string taskID, string runID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetTasksIDRunsIDAsyncWithHttpInfo(taskID, runID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve a single run for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Run)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Run>> GetTasksIDRunsIDAsyncWithHttpInfo(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetTasksIDRunsIDAsyncWithIRestResponse(taskID, runID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Retrieve a single run for a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Run)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDRunsIDAsyncWithIRestResponse(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("GetTasksIDRunsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve all logs for a run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Logs</returns>
        public Logs GetTasksIDRunsIDLogs(string taskID, string runID, string zapTraceSpan = null)
        {
            var localVarResponse = GetTasksIDRunsIDLogsWithHttpInfo(taskID, runID, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve all logs for a run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Logs</returns>
        public ApiResponse<Logs> GetTasksIDRunsIDLogsWithHttpInfo(string taskID, string runID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsIDLogs");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("GetTasksIDRunsIDLogs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Retrieve all logs for a run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Logs</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDRunsIDLogsWithIRestResponseAsync(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsIDLogs");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("GetTasksIDRunsIDLogs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve all logs for a run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Logs</returns>
        public RestResponse GetTasksIDRunsIDLogsWithIRestResponse(string taskID, string runID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsIDLogs");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("GetTasksIDRunsIDLogs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve all logs for a run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Logs</returns>
        public RestRequest GetTasksIDRunsIDLogsWithRestRequest(string taskID, string runID, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsIDLogs");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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 all logs for a run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Logs</returns>
        public async System.Threading.Tasks.Task<Logs> GetTasksIDRunsIDLogsAsync(string taskID, string runID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetTasksIDRunsIDLogsAsyncWithHttpInfo(taskID, runID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve all logs for a run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Logs)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Logs>> GetTasksIDRunsIDLogsAsyncWithHttpInfo(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetTasksIDRunsIDLogsAsyncWithIRestResponse(taskID, runID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Retrieve all logs for a run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">ID of task to get logs for.</param>
        /// <param name="runID">ID of run to get logs for.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Logs)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTasksIDRunsIDLogsAsyncWithIRestResponse(string taskID,
            string runID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->GetTasksIDRunsIDLogs");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/logs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

            if (runID != null)
            {
                localVarPathParams.Add("runID", Configuration.ApiClient.ParameterToString(runID)); // 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("GetTasksIDRunsIDLogs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Update a task Update a task. This will cancel all queued runs.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>TaskType</returns>
        public TaskType PatchTasksID(string taskID, TaskUpdateRequest taskUpdateRequest, string zapTraceSpan = null)
        {
            var localVarResponse = PatchTasksIDWithHttpInfo(taskID, taskUpdateRequest, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a task Update a task. This will cancel all queued runs.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of TaskType</returns>
        public ApiResponse<TaskType> PatchTasksIDWithHttpInfo(string taskID, TaskUpdateRequest taskUpdateRequest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PatchTasksID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

        /// <summary>
        /// Update a task Update a task. This will cancel all queued runs.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of TaskType</returns>
        public async System.Threading.Tasks.Task<RestResponse> PatchTasksIDWithIRestResponseAsync(string taskID,
            TaskUpdateRequest taskUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PatchTasksID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a task Update a task. This will cancel all queued runs.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of TaskType</returns>
        public RestResponse PatchTasksIDWithIRestResponse(string taskID, TaskUpdateRequest taskUpdateRequest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PatchTasksID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a task Update a task. This will cancel all queued runs.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of TaskType</returns>
        public RestRequest PatchTasksIDWithRestRequest(string taskID, TaskUpdateRequest taskUpdateRequest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PatchTasksID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

            if (taskUpdateRequest != null && taskUpdateRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(taskUpdateRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = taskUpdateRequest; // 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 task Update a task. This will cancel all queued runs.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of TaskType</returns>
        public async System.Threading.Tasks.Task<TaskType> PatchTasksIDAsync(string taskID,
            TaskUpdateRequest taskUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PatchTasksIDAsyncWithHttpInfo(taskID, taskUpdateRequest, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a task Update a task. This will cancel all queued runs.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (TaskType)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<TaskType>> PatchTasksIDAsyncWithHttpInfo(string taskID,
            TaskUpdateRequest taskUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PatchTasksIDAsyncWithIRestResponse(taskID, taskUpdateRequest, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Update a task Update a task. This will cancel all queued runs.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="taskUpdateRequest">Task update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (TaskType)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PatchTasksIDAsyncWithIRestResponse(string taskID,
            TaskUpdateRequest taskUpdateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PatchTasksID");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Create a new task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>TaskType</returns>
        public TaskType PostTasks(TaskCreateRequest taskCreateRequest, string zapTraceSpan = null)
        {
            var localVarResponse = PostTasksWithHttpInfo(taskCreateRequest, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Create a new task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of TaskType</returns>
        public ApiResponse<TaskType> PostTasksWithHttpInfo(TaskCreateRequest taskCreateRequest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskCreateRequest' is set
            if (taskCreateRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskCreateRequest' when calling TasksService->PostTasks");
            }

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

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Create a new task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of TaskType</returns>
        public RestResponse PostTasksWithIRestResponse(TaskCreateRequest taskCreateRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskCreateRequest' is set
            if (taskCreateRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskCreateRequest' when calling TasksService->PostTasks");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// Create a new task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of TaskType</returns>
        public RestRequest PostTasksWithRestRequest(TaskCreateRequest taskCreateRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskCreateRequest' is set
            if (taskCreateRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskCreateRequest' when calling TasksService->PostTasks");
            }

            var localVarPath = "/api/v2/tasks";
            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 (taskCreateRequest != null && taskCreateRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(taskCreateRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = taskCreateRequest; // byte array
            }

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

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


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

        /// <summary>
        /// Create a new task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of TaskType</returns>
        public async System.Threading.Tasks.Task<TaskType> PostTasksAsync(TaskCreateRequest taskCreateRequest,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await PostTasksAsyncWithHttpInfo(taskCreateRequest, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Create a new task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskCreateRequest">Task to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (TaskType)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<TaskType>> PostTasksAsyncWithHttpInfo(
            TaskCreateRequest taskCreateRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostTasksAsyncWithIRestResponse(taskCreateRequest, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a label to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>LabelResponse</returns>
        public LabelResponse PostTasksIDLabels(string taskID, LabelMapping labelMapping, string zapTraceSpan = null)
        {
            var localVarResponse = PostTasksIDLabelsWithHttpInfo(taskID, labelMapping, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add a label to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of LabelResponse</returns>
        public ApiResponse<LabelResponse> PostTasksIDLabelsWithHttpInfo(string taskID, LabelMapping labelMapping,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDLabels");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

        /// <summary>
        /// Add a label to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of LabelResponse</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDLabelsWithIRestResponseAsync(string taskID,
            LabelMapping labelMapping, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDLabels");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a label to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of LabelResponse</returns>
        public RestResponse PostTasksIDLabelsWithIRestResponse(string taskID, LabelMapping labelMapping,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDLabels");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a label to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of LabelResponse</returns>
        public RestRequest PostTasksIDLabelsWithRestRequest(string taskID, LabelMapping labelMapping,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDLabels");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

            if (labelMapping != null && labelMapping.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(labelMapping); // http body (model) parameter
            }
            else
            {
                localVarPostBody = labelMapping; // 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>
        /// Add a label to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of LabelResponse</returns>
        public async System.Threading.Tasks.Task<LabelResponse> PostTasksIDLabelsAsync(string taskID,
            LabelMapping labelMapping, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostTasksIDLabelsAsyncWithHttpInfo(taskID, labelMapping, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add a label to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (LabelResponse)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<LabelResponse>> PostTasksIDLabelsAsyncWithHttpInfo(
            string taskID, LabelMapping labelMapping, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostTasksIDLabelsAsyncWithIRestResponse(taskID, labelMapping, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Add a label to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="labelMapping">Label to add</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (LabelResponse)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDLabelsAsyncWithIRestResponse(string taskID,
            LabelMapping labelMapping, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDLabels");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/labels";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a member to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceMember</returns>
        public ResourceMember PostTasksIDMembers(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            var localVarResponse = PostTasksIDMembersWithHttpInfo(taskID, addResourceMemberRequestBody, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add a member to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMember</returns>
        public ApiResponse<ResourceMember> PostTasksIDMembersWithHttpInfo(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDMembers");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

        /// <summary>
        /// Add a member to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of ResourceMember</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDMembersWithIRestResponseAsync(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDMembers");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a member to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMember</returns>
        public RestResponse PostTasksIDMembersWithIRestResponse(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDMembers");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a member to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMember</returns>
        public RestRequest PostTasksIDMembersWithRestRequest(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDMembers");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

            if (addResourceMemberRequestBody != null && addResourceMemberRequestBody.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(addResourceMemberRequestBody); // http body (model) parameter
            }
            else
            {
                localVarPostBody = addResourceMemberRequestBody; // 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>
        /// Add a member to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ResourceMember</returns>
        public async System.Threading.Tasks.Task<ResourceMember> PostTasksIDMembersAsync(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostTasksIDMembersAsyncWithHttpInfo(taskID, addResourceMemberRequestBody, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add a member to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ResourceMember)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<ResourceMember>> PostTasksIDMembersAsyncWithHttpInfo(
            string taskID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostTasksIDMembersAsyncWithIRestResponse(taskID, addResourceMemberRequestBody, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Add a member to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as member</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (ResourceMember)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDMembersAsyncWithIRestResponse(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDMembers");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/members";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add an owner to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceOwner</returns>
        public ResourceOwner PostTasksIDOwners(string taskID, AddResourceMemberRequestBody addResourceMemberRequestBody,
            string zapTraceSpan = null)
        {
            var localVarResponse = PostTasksIDOwnersWithHttpInfo(taskID, addResourceMemberRequestBody, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add an owner to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceOwner</returns>
        public ApiResponse<ResourceOwner> PostTasksIDOwnersWithHttpInfo(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDOwners");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

        /// <summary>
        /// Add an owner to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of ResourceOwner</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDOwnersWithIRestResponseAsync(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDOwners");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add an owner to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceOwner</returns>
        public RestResponse PostTasksIDOwnersWithIRestResponse(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDOwners");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add an owner to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceOwner</returns>
        public RestRequest PostTasksIDOwnersWithRestRequest(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDOwners");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

            if (addResourceMemberRequestBody != null && addResourceMemberRequestBody.GetType() != typeof(byte[]))
            {
                localVarPostBody =
                    Configuration.ApiClient.Serialize(addResourceMemberRequestBody); // http body (model) parameter
            }
            else
            {
                localVarPostBody = addResourceMemberRequestBody; // 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>
        /// Add an owner to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ResourceOwner</returns>
        public async System.Threading.Tasks.Task<ResourceOwner> PostTasksIDOwnersAsync(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostTasksIDOwnersAsyncWithHttpInfo(taskID, addResourceMemberRequestBody, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add an owner to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ResourceOwner)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<ResourceOwner>> PostTasksIDOwnersAsyncWithHttpInfo(
            string taskID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostTasksIDOwnersAsyncWithIRestResponse(taskID, addResourceMemberRequestBody, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Add an owner to a task 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="addResourceMemberRequestBody">User to add as owner</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (ResourceOwner)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDOwnersAsyncWithIRestResponse(string taskID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDOwners");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/owners";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Manually start a task run, overriding the current schedule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <returns>Run</returns>
        public Run PostTasksIDRuns(string taskID, string zapTraceSpan = null, RunManually runManually = null)
        {
            var localVarResponse = PostTasksIDRunsWithHttpInfo(taskID, zapTraceSpan, runManually);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Manually start a task run, overriding the current schedule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        public ApiResponse<Run> PostTasksIDRunsWithHttpInfo(string taskID, string zapTraceSpan = null,
            RunManually runManually = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

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

        /// <summary>
        /// Manually start a task run, overriding the current schedule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Run</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDRunsWithIRestResponseAsync(string taskID,
            string zapTraceSpan = null, RunManually runManually = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Manually start a task run, overriding the current schedule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        public RestResponse PostTasksIDRunsWithIRestResponse(string taskID, string zapTraceSpan = null,
            RunManually runManually = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Manually start a task run, overriding the current schedule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        public RestRequest PostTasksIDRunsWithRestRequest(string taskID, string zapTraceSpan = null,
            RunManually runManually = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

            if (runManually != null && runManually.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(runManually); // http body (model) parameter
            }
            else
            {
                localVarPostBody = runManually; // 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>
        /// Manually start a task run, overriding the current schedule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Run</returns>
        public async System.Threading.Tasks.Task<Run> PostTasksIDRunsAsync(string taskID, string zapTraceSpan = null,
            RunManually runManually = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostTasksIDRunsAsyncWithHttpInfo(taskID, zapTraceSpan, runManually, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Manually start a task run, overriding the current schedule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Run)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Run>> PostTasksIDRunsAsyncWithHttpInfo(string taskID,
            string zapTraceSpan = null, RunManually runManually = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostTasksIDRunsAsyncWithIRestResponse(taskID, zapTraceSpan, runManually, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Manually start a task run, overriding the current schedule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID"></param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="runManually"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Run)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDRunsAsyncWithIRestResponse(string taskID,
            string zapTraceSpan = null, RunManually runManually = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRuns");
            }

            var localVarPath = "/api/v2/tasks/{taskID}/runs";
            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 (taskID != null)
            {
                localVarPathParams.Add("taskID", Configuration.ApiClient.ParameterToString(taskID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Retry a task run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <returns>Run</returns>
        public Run PostTasksIDRunsIDRetry(string taskID, string runID, string zapTraceSpan = null, string body = null)
        {
            var localVarResponse = PostTasksIDRunsIDRetryWithHttpInfo(taskID, runID, zapTraceSpan, body);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retry a task run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        public ApiResponse<Run> PostTasksIDRunsIDRetryWithHttpInfo(string taskID, string runID,
            string zapTraceSpan = null, string body = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRunsIDRetry");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/retry";
            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; charset=utf-8"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

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

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

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

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


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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Retry a task run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Run</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDRunsIDRetryWithIRestResponseAsync(
            string taskID, string runID, string zapTraceSpan = null, string body = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRunsIDRetry");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/retry";
            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; charset=utf-8"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

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

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

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

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


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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Retry a task run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        public RestResponse PostTasksIDRunsIDRetryWithIRestResponse(string taskID, string runID,
            string zapTraceSpan = null, string body = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRunsIDRetry");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/retry";
            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; charset=utf-8"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

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

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

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

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


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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Retry a task run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <returns>ApiResponse of Run</returns>
        public RestRequest PostTasksIDRunsIDRetryWithRestRequest(string taskID, string runID,
            string zapTraceSpan = null, string body = null)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRunsIDRetry");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/retry";
            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; charset=utf-8"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

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

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

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

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


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

        /// <summary>
        /// Retry a task run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Run</returns>
        public async System.Threading.Tasks.Task<Run> PostTasksIDRunsIDRetryAsync(string taskID, string runID,
            string zapTraceSpan = null, string body = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostTasksIDRunsIDRetryAsyncWithHttpInfo(taskID, runID, zapTraceSpan, body, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retry a task run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Run)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Run>> PostTasksIDRunsIDRetryAsyncWithHttpInfo(
            string taskID, string runID, string zapTraceSpan = null, string body = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostTasksIDRunsIDRetryAsyncWithIRestResponse(taskID, runID, zapTraceSpan, body, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Retry a task run 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="taskID">The task ID.</param>
        /// <param name="runID">The run ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="body"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Run)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PostTasksIDRunsIDRetryAsyncWithIRestResponse(
            string taskID, string runID, string zapTraceSpan = null, string body = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'taskID' is set
            if (taskID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'taskID' when calling TasksService->PostTasksIDRunsIDRetry");
            }

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

            var localVarPath = "/api/v2/tasks/{taskID}/runs/{runID}/retry";
            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; charset=utf-8"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

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

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

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

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


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

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

            return localVarResponse;
        }
    }
}