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

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

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

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

        /// <summary>
        /// Delete a label from a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> DeleteTelegrafsIDLabelsIDWithHttpInfo(string telegrafID, string labelID,
            string zapTraceSpan = null);

        /// <summary>
        /// Remove a member from a Telegraf config
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        void DeleteTelegrafsIDMembersID(string userID, string telegrafID, string zapTraceSpan = null);

        /// <summary>
        /// Remove a member from a Telegraf config
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> DeleteTelegrafsIDMembersIDWithHttpInfo(string userID, string telegrafID,
            string zapTraceSpan = null);

        /// <summary>
        /// Remove an owner from a Telegraf config
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        void DeleteTelegrafsIDOwnersID(string userID, string telegrafID, string zapTraceSpan = null);

        /// <summary>
        /// Remove an owner from a Telegraf config
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> DeleteTelegrafsIDOwnersIDWithHttpInfo(string userID, string telegrafID,
            string zapTraceSpan = null);

        /// <summary>
        /// List all Telegraf configurations
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <returns>Telegrafs</returns>
        Telegrafs GetTelegrafs(string zapTraceSpan = null, string orgID = null);

        /// <summary>
        /// List all Telegraf configurations
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <returns>ApiResponse of Telegrafs</returns>
        ApiResponse<Telegrafs> GetTelegrafsWithHttpInfo(string zapTraceSpan = null, string orgID = null);

        /// <summary>
        /// Retrieve a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="accept"> (optional, default to application/toml)</param>
        /// <returns>string</returns>
        string GetTelegrafsID(string telegrafID, string zapTraceSpan = null, string accept = null);

        /// <summary>
        /// Retrieve a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="accept"> (optional, default to application/toml)</param>
        /// <returns>ApiResponse of string</returns>
        ApiResponse<string> GetTelegrafsIDWithHttpInfo(string telegrafID, string zapTraceSpan = null,
            string accept = null);

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

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

        /// <summary>
        /// List all users with member privileges for a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceMembers</returns>
        ResourceMembers GetTelegrafsIDMembers(string telegrafID, string zapTraceSpan = null);

        /// <summary>
        /// List all users with member privileges for a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMembers</returns>
        ApiResponse<ResourceMembers> GetTelegrafsIDMembersWithHttpInfo(string telegrafID, string zapTraceSpan = null);

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

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

        /// <summary>
        /// Create a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafPluginRequest">Telegraf configuration to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Telegraf</returns>
        Telegraf PostTelegrafs(TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null);

        /// <summary>
        /// Create a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafPluginRequest">Telegraf configuration to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Telegraf</returns>
        ApiResponse<Telegraf> PostTelegrafsWithHttpInfo(TelegrafPluginRequest telegrafPluginRequest,
            string zapTraceSpan = null);

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

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

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

        /// <summary>
        /// Add a member to a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDMembersWithHttpInfo(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null);

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

        /// <summary>
        /// Add an owner to a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> PostTelegrafsIDOwnersWithHttpInfo(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null);

        /// <summary>
        /// Update a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Telegraf</returns>
        Telegraf PutTelegrafsID(string telegrafID, TelegrafPluginRequest telegrafPluginRequest,
            string zapTraceSpan = null);

        /// <summary>
        /// Update a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Telegraf</returns>
        ApiResponse<Telegraf> PutTelegrafsIDWithHttpInfo(string telegrafID, TelegrafPluginRequest telegrafPluginRequest,
            string zapTraceSpan = null);

        #endregion Synchronous Operations

        #region Asynchronous Operations

        /// <summary>
        /// Delete a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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 DeleteTelegrafsIDAsync(string telegrafID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Delete a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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>> DeleteTelegrafsIDAsyncWithHttpInfo(string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

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

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

        /// <summary>
        /// Remove a member from a Telegraf config
        /// </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="telegrafID">The Telegraf config 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 DeleteTelegrafsIDMembersIDAsync(string userID, string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Remove a member from a Telegraf config
        /// </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="telegrafID">The Telegraf config 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>> DeleteTelegrafsIDMembersIDAsyncWithHttpInfo(string userID,
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Remove an owner from a Telegraf config
        /// </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="telegrafID">The Telegraf config 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 DeleteTelegrafsIDOwnersIDAsync(string userID, string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Remove an owner from a Telegraf config
        /// </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="telegrafID">The Telegraf config 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>> DeleteTelegrafsIDOwnersIDAsyncWithHttpInfo(string userID,
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all Telegraf configurations
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Telegrafs</returns>
        System.Threading.Tasks.Task<Telegrafs> GetTelegrafsAsync(string zapTraceSpan = null, string orgID = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// List all Telegraf configurations
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Telegrafs)</returns>
        System.Threading.Tasks.Task<ApiResponse<Telegrafs>> GetTelegrafsAsyncWithHttpInfo(string zapTraceSpan = null,
            string orgID = null, CancellationToken cancellationToken = default);

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

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

        /// <summary>
        /// List all labels for a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> GetTelegrafsIDLabelsAsync(string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all labels for a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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>> GetTelegrafsIDLabelsAsyncWithHttpInfo(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all users with member privileges for a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> GetTelegrafsIDMembersAsync(string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all users with member privileges for a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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>> GetTelegrafsIDMembersAsyncWithHttpInfo(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all owners of a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> GetTelegrafsIDOwnersAsync(string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all owners of a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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>> GetTelegrafsIDOwnersAsyncWithHttpInfo(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default);

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

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

        /// <summary>
        /// Add a label to a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDLabelsAsync(string telegrafID,
            LabelMapping labelMapping, string zapTraceSpan = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Add a label to a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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>> PostTelegrafsIDLabelsAsyncWithHttpInfo(
            string telegrafID, LabelMapping labelMapping, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Add a member to a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDMembersAsync(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Add a member to a Telegraf config
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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>> PostTelegrafsIDMembersAsyncWithHttpInfo(
            string telegrafID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Add an owner to a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> PostTelegrafsIDOwnersAsync(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Add an owner to a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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>> PostTelegrafsIDOwnersAsyncWithHttpInfo(
            string telegrafID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Telegraf</returns>
        System.Threading.Tasks.Task<Telegraf> PutTelegrafsIDAsync(string telegrafID,
            TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a Telegraf configuration
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Telegraf)</returns>
        System.Threading.Tasks.Task<ApiResponse<Telegraf>> PutTelegrafsIDAsyncWithHttpInfo(string telegrafID,
            TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        #endregion Asynchronous Operations
    }

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

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

            ExceptionFactory = Configuration.DefaultExceptionFactory;
        }

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

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

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

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

        /// <summary>
        /// Delete a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> DeleteTelegrafsIDWithIRestResponseAsync(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->DeleteTelegrafsID");
            }

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

            return localVarResponse;
        }

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

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

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}";
            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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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 DeleteTelegrafsIDAsync(string telegrafID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            return DeleteTelegrafsIDAsyncWithHttpInfo(telegrafID, zapTraceSpan, cancellationToken);
        }

        /// <summary>
        /// Delete a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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>> DeleteTelegrafsIDAsyncWithHttpInfo(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await DeleteTelegrafsIDAsyncWithIRestResponse(telegrafID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Delete a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> DeleteTelegrafsIDAsyncWithIRestResponse(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->DeleteTelegrafsID");
            }

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

            return localVarResponse;
        }

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

        /// <summary>
        /// Delete a label from a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> DeleteTelegrafsIDLabelsIDWithHttpInfo(string telegrafID, string labelID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->DeleteTelegrafsIDLabelsID");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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("DeleteTelegrafsIDLabelsID", 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> DeleteTelegrafsIDLabelsIDWithIRestResponseAsync(
            string telegrafID, string labelID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->DeleteTelegrafsIDLabelsID");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Delete a label from a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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 DeleteTelegrafsIDLabelsIDWithIRestResponse(string telegrafID, string labelID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->DeleteTelegrafsIDLabelsID");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Delete a label from a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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 DeleteTelegrafsIDLabelsIDWithRestRequest(string telegrafID, string labelID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->DeleteTelegrafsIDLabelsID");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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 DeleteTelegrafsIDLabelsIDAsync(string telegrafID, string labelID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            return DeleteTelegrafsIDLabelsIDAsyncWithHttpInfo(telegrafID, labelID, zapTraceSpan, cancellationToken);
        }

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("DeleteTelegrafsIDLabelsID", 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> DeleteTelegrafsIDLabelsIDAsyncWithIRestResponse(
            string telegrafID, string labelID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->DeleteTelegrafsIDLabelsID");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Remove a member from a Telegraf config 
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteTelegrafsIDMembersID(string userID, string telegrafID, string zapTraceSpan = null)
        {
            DeleteTelegrafsIDMembersIDWithHttpInfo(userID, telegrafID, zapTraceSpan);
        }

        /// <summary>
        /// Remove a member from a Telegraf config 
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> DeleteTelegrafsIDMembersIDWithHttpInfo(string userID, string telegrafID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TelegrafsService->DeleteTelegrafsIDMembersID");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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("DeleteTelegrafsIDMembersID", 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 Telegraf config 
        /// </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="telegrafID">The Telegraf config 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> DeleteTelegrafsIDMembersIDWithIRestResponseAsync(
            string userID, string telegrafID, 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 TelegrafsService->DeleteTelegrafsIDMembersID");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Remove a member from a Telegraf config 
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse DeleteTelegrafsIDMembersIDWithIRestResponse(string userID, string telegrafID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TelegrafsService->DeleteTelegrafsIDMembersID");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Remove a member from a Telegraf config 
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest DeleteTelegrafsIDMembersIDWithRestRequest(string userID, string telegrafID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TelegrafsService->DeleteTelegrafsIDMembersID");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 Telegraf config 
        /// </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="telegrafID">The Telegraf config 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 DeleteTelegrafsIDMembersIDAsync(string userID, string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            return DeleteTelegrafsIDMembersIDAsyncWithHttpInfo(userID, telegrafID, zapTraceSpan, cancellationToken);
        }

        /// <summary>
        /// Remove a member from a Telegraf config 
        /// </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="telegrafID">The Telegraf config 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>> DeleteTelegrafsIDMembersIDAsyncWithHttpInfo(
            string userID, string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await DeleteTelegrafsIDMembersIDAsyncWithIRestResponse(userID, telegrafID, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("DeleteTelegrafsIDMembersID", 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 Telegraf config 
        /// </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="telegrafID">The Telegraf config 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> DeleteTelegrafsIDMembersIDAsyncWithIRestResponse(
            string userID, string telegrafID, 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 TelegrafsService->DeleteTelegrafsIDMembersID");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Remove an owner from a Telegraf config 
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteTelegrafsIDOwnersID(string userID, string telegrafID, string zapTraceSpan = null)
        {
            DeleteTelegrafsIDOwnersIDWithHttpInfo(userID, telegrafID, zapTraceSpan);
        }

        /// <summary>
        /// Remove an owner from a Telegraf config 
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> DeleteTelegrafsIDOwnersIDWithHttpInfo(string userID, string telegrafID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TelegrafsService->DeleteTelegrafsIDOwnersID");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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("DeleteTelegrafsIDOwnersID", 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 Telegraf config 
        /// </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="telegrafID">The Telegraf config 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> DeleteTelegrafsIDOwnersIDWithIRestResponseAsync(
            string userID, string telegrafID, 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 TelegrafsService->DeleteTelegrafsIDOwnersID");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Remove an owner from a Telegraf config 
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse DeleteTelegrafsIDOwnersIDWithIRestResponse(string userID, string telegrafID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TelegrafsService->DeleteTelegrafsIDOwnersID");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Remove an owner from a Telegraf config 
        /// </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="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest DeleteTelegrafsIDOwnersIDWithRestRequest(string userID, string telegrafID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'userID' is set
            if (userID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'userID' when calling TelegrafsService->DeleteTelegrafsIDOwnersID");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 Telegraf config 
        /// </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="telegrafID">The Telegraf config 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 DeleteTelegrafsIDOwnersIDAsync(string userID, string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            return DeleteTelegrafsIDOwnersIDAsyncWithHttpInfo(userID, telegrafID, zapTraceSpan, cancellationToken);
        }

        /// <summary>
        /// Remove an owner from a Telegraf config 
        /// </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="telegrafID">The Telegraf config 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>> DeleteTelegrafsIDOwnersIDAsyncWithHttpInfo(
            string userID, string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await DeleteTelegrafsIDOwnersIDAsyncWithIRestResponse(userID, telegrafID, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("DeleteTelegrafsIDOwnersID", 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 Telegraf config 
        /// </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="telegrafID">The Telegraf config 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> DeleteTelegrafsIDOwnersIDAsyncWithIRestResponse(
            string userID, string telegrafID, 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 TelegrafsService->DeleteTelegrafsIDOwnersID");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// List all Telegraf configurations 
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <returns>Telegrafs</returns>
        public Telegrafs GetTelegrafs(string zapTraceSpan = null, string orgID = null)
        {
            var localVarResponse = GetTelegrafsWithHttpInfo(zapTraceSpan, orgID);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all Telegraf configurations 
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <returns>ApiResponse of Telegrafs</returns>
        public ApiResponse<Telegrafs> GetTelegrafsWithHttpInfo(string zapTraceSpan = null, string orgID = null)
        {
            var localVarPath = "/api/v2/telegrafs";
            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 (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // 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("GetTelegrafs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// List all Telegraf configurations 
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Telegrafs</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTelegrafsWithIRestResponseAsync(
            string zapTraceSpan = null, string orgID = null, CancellationToken cancellationToken = default)
        {
            var localVarPath = "/api/v2/telegrafs";
            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 (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // 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("GetTelegrafs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all Telegraf configurations 
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <returns>ApiResponse of Telegrafs</returns>
        public RestResponse GetTelegrafsWithIRestResponse(string zapTraceSpan = null, string orgID = null)
        {
            var localVarPath = "/api/v2/telegrafs";
            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 (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // 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("GetTelegrafs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all Telegraf configurations 
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <returns>ApiResponse of Telegrafs</returns>
        public RestRequest GetTelegrafsWithRestRequest(string zapTraceSpan = null, string orgID = null)
        {
            var localVarPath = "/api/v2/telegrafs";
            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 (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // 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 Telegraf configurations 
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Telegrafs</returns>
        public async System.Threading.Tasks.Task<Telegrafs> GetTelegrafsAsync(string zapTraceSpan = null,
            string orgID = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await GetTelegrafsAsyncWithHttpInfo(zapTraceSpan, orgID, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all Telegraf configurations 
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Telegrafs)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Telegrafs>> GetTelegrafsAsyncWithHttpInfo(
            string zapTraceSpan = null, string orgID = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await GetTelegrafsAsyncWithIRestResponse(zapTraceSpan, orgID, cancellationToken)
                .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List all Telegraf configurations 
        /// </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="orgID">The organization ID the Telegraf config belongs to. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Telegrafs)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetTelegrafsAsyncWithIRestResponse(
            string zapTraceSpan = null, string orgID = null, CancellationToken cancellationToken = default)
        {
            var localVarPath = "/api/v2/telegrafs";
            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 (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // 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("GetTelegrafs", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="accept"> (optional, default to application/toml)</param>
        /// <returns>string</returns>
        public string GetTelegrafsID(string telegrafID, string zapTraceSpan = null, string accept = null)
        {
            var localVarResponse = GetTelegrafsIDWithHttpInfo(telegrafID, zapTraceSpan, accept);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="accept"> (optional, default to application/toml)</param>
        /// <returns>ApiResponse of string</returns>
        public ApiResponse<string> GetTelegrafsIDWithHttpInfo(string telegrafID, string zapTraceSpan = null,
            string accept = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsID");
            }

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

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

            if (accept != null)
            {
                localVarHeaderParams.Add("Accept",
                    Configuration.ApiClient.ParameterToString(accept)); // header parameter
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/toml",
                "application/json",
                "application/octet-stream"
            };

            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("GetTelegrafsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

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

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

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

            if (accept != null)
            {
                localVarHeaderParams.Add("Accept",
                    Configuration.ApiClient.ParameterToString(accept)); // header parameter
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/toml",
                "application/json",
                "application/octet-stream"
            };

            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("GetTelegrafsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="accept"> (optional, default to application/toml)</param>
        /// <returns>ApiResponse of string</returns>
        public RestResponse GetTelegrafsIDWithIRestResponse(string telegrafID, string zapTraceSpan = null,
            string accept = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsID");
            }

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

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

            if (accept != null)
            {
                localVarHeaderParams.Add("Accept",
                    Configuration.ApiClient.ParameterToString(accept)); // header parameter
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/toml",
                "application/json",
                "application/octet-stream"
            };

            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("GetTelegrafsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="accept"> (optional, default to application/toml)</param>
        /// <returns>ApiResponse of string</returns>
        public RestRequest GetTelegrafsIDWithRestRequest(string telegrafID, string zapTraceSpan = null,
            string accept = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsID");
            }

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

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

            if (accept != null)
            {
                localVarHeaderParams.Add("Accept",
                    Configuration.ApiClient.ParameterToString(accept)); // header parameter
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/toml",
                "application/json",
                "application/octet-stream"
            };

            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 Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="accept"> (optional, default to application/toml)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of string</returns>
        public async System.Threading.Tasks.Task<string> GetTelegrafsIDAsync(string telegrafID,
            string zapTraceSpan = null, string accept = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetTelegrafsIDAsyncWithHttpInfo(telegrafID, zapTraceSpan, accept, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

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

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

            if (accept != null)
            {
                localVarHeaderParams.Add("Accept",
                    Configuration.ApiClient.ParameterToString(accept)); // header parameter
            }

            // to determine the Accept header
            var localVarHttpHeaderAccepts = new string[]
            {
                "application/toml",
                "application/json",
                "application/octet-stream"
            };

            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("GetTelegrafsID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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("GetTelegrafsIDLabels", 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> GetTelegrafsIDLabelsWithIRestResponseAsync(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsIDLabels");
            }

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

            return localVarResponse;
        }

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

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

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> GetTelegrafsIDLabelsAsync(string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetTelegrafsIDLabelsAsyncWithHttpInfo(telegrafID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all labels for a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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>> GetTelegrafsIDLabelsAsyncWithHttpInfo(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetTelegrafsIDLabelsAsyncWithIRestResponse(telegrafID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("GetTelegrafsIDLabels", 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> GetTelegrafsIDLabelsAsyncWithIRestResponse(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsIDLabels");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// List all users with member privileges for a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ResourceMembers</returns>
        public ResourceMembers GetTelegrafsIDMembers(string telegrafID, string zapTraceSpan = null)
        {
            var localVarResponse = GetTelegrafsIDMembersWithHttpInfo(telegrafID, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all users with member privileges for a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMembers</returns>
        public ApiResponse<ResourceMembers> GetTelegrafsIDMembersWithHttpInfo(string telegrafID,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsIDMembers");
            }

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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("GetTelegrafsIDMembers", 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 users with member privileges for a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> GetTelegrafsIDMembersWithIRestResponseAsync(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsIDMembers");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// List all users with member privileges for a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMembers</returns>
        public RestResponse GetTelegrafsIDMembersWithIRestResponse(string telegrafID, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsIDMembers");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// List all users with member privileges for a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of ResourceMembers</returns>
        public RestRequest GetTelegrafsIDMembersWithRestRequest(string telegrafID, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsIDMembers");
            }

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 users with member privileges for a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> GetTelegrafsIDMembersAsync(string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetTelegrafsIDMembersAsyncWithHttpInfo(telegrafID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all users with member privileges for a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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>> GetTelegrafsIDMembersAsyncWithHttpInfo(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetTelegrafsIDMembersAsyncWithIRestResponse(telegrafID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("GetTelegrafsIDMembers", 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 users with member privileges for a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> GetTelegrafsIDMembersAsyncWithIRestResponse(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsIDMembers");
            }

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

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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("GetTelegrafsIDOwners", 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 Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> GetTelegrafsIDOwnersWithIRestResponseAsync(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsIDOwners");
            }

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

            return localVarResponse;
        }

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

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

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> GetTelegrafsIDOwnersAsync(string telegrafID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetTelegrafsIDOwnersAsyncWithHttpInfo(telegrafID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all owners of a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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>> GetTelegrafsIDOwnersAsyncWithHttpInfo(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetTelegrafsIDOwnersAsyncWithIRestResponse(telegrafID, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("GetTelegrafsIDOwners", 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 Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> GetTelegrafsIDOwnersAsyncWithIRestResponse(
            string telegrafID, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->GetTelegrafsIDOwners");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// Create a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafPluginRequest">Telegraf configuration to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Telegraf</returns>
        public Telegraf PostTelegrafs(TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null)
        {
            var localVarResponse = PostTelegrafsWithHttpInfo(telegrafPluginRequest, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Create a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafPluginRequest">Telegraf configuration to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Telegraf</returns>
        public ApiResponse<Telegraf> PostTelegrafsWithHttpInfo(TelegrafPluginRequest telegrafPluginRequest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafPluginRequest' is set
            if (telegrafPluginRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafPluginRequest' when calling TelegrafsService->PostTelegrafs");
            }

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

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Create a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafPluginRequest">Telegraf configuration to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Telegraf</returns>
        public RestResponse PostTelegrafsWithIRestResponse(TelegrafPluginRequest telegrafPluginRequest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafPluginRequest' is set
            if (telegrafPluginRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafPluginRequest' when calling TelegrafsService->PostTelegrafs");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// Create a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafPluginRequest">Telegraf configuration to create</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Telegraf</returns>
        public RestRequest PostTelegrafsWithRestRequest(TelegrafPluginRequest telegrafPluginRequest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafPluginRequest' is set
            if (telegrafPluginRequest == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafPluginRequest' when calling TelegrafsService->PostTelegrafs");
            }

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

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

            return localVarResponse;
        }

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

        /// <summary>
        /// Add a label to a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDLabelsWithHttpInfo(string telegrafID,
            LabelMapping labelMapping, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDLabels");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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("PostTelegrafsIDLabels", 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDLabelsWithIRestResponseAsync(
            string telegrafID, LabelMapping labelMapping, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDLabels");
            }

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

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

            return localVarResponse;
        }

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

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

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

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDLabelsAsync(string telegrafID,
            LabelMapping labelMapping, string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostTelegrafsIDLabelsAsyncWithHttpInfo(telegrafID, labelMapping, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add a label to a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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>> PostTelegrafsIDLabelsAsyncWithHttpInfo(
            string telegrafID, LabelMapping labelMapping, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostTelegrafsIDLabelsAsyncWithIRestResponse(telegrafID, labelMapping, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostTelegrafsIDLabels", 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDLabelsAsyncWithIRestResponse(
            string telegrafID, LabelMapping labelMapping, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDLabels");
            }

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

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

            return localVarResponse;
        }

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

        /// <summary>
        /// Add a member to a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDMembersWithHttpInfo(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDMembers");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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("PostTelegrafsIDMembers", 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDMembersWithIRestResponseAsync(
            string telegrafID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDMembers");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a member to a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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 PostTelegrafsIDMembersWithIRestResponse(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDMembers");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a member to a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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 PostTelegrafsIDMembersWithRestRequest(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDMembers");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDMembersAsync(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostTelegrafsIDMembersAsyncWithHttpInfo(telegrafID, addResourceMemberRequestBody, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add a member to a Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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>> PostTelegrafsIDMembersAsyncWithHttpInfo(
            string telegrafID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostTelegrafsIDMembersAsyncWithIRestResponse(telegrafID, addResourceMemberRequestBody,
                    zapTraceSpan, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostTelegrafsIDMembers", 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 Telegraf config 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config 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> PostTelegrafsIDMembersAsyncWithIRestResponse(
            string telegrafID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDMembers");
            }

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

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

            return localVarResponse;
        }

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

        /// <summary>
        /// Add an owner to a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> PostTelegrafsIDOwnersWithHttpInfo(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDOwners");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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("PostTelegrafsIDOwners", 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 Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> PostTelegrafsIDOwnersWithIRestResponseAsync(
            string telegrafID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDOwners");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add an owner to a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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 PostTelegrafsIDOwnersWithIRestResponse(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDOwners");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Add an owner to a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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 PostTelegrafsIDOwnersWithRestRequest(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDOwners");
            }

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

            var localVarPath = "/api/v2/telegrafs/{telegrafID}/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 (telegrafID != null)
            {
                localVarPathParams.Add("telegrafID",
                    Configuration.ApiClient.ParameterToString(telegrafID)); // 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 Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> PostTelegrafsIDOwnersAsync(string telegrafID,
            AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PostTelegrafsIDOwnersAsyncWithHttpInfo(telegrafID, addResourceMemberRequestBody, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add an owner to a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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>> PostTelegrafsIDOwnersAsyncWithHttpInfo(
            string telegrafID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PostTelegrafsIDOwnersAsyncWithIRestResponse(telegrafID, addResourceMemberRequestBody,
                    zapTraceSpan, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

            if (ExceptionFactory != null)
            {
                var exception = ExceptionFactory("PostTelegrafsIDOwners", 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 Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf configuration 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> PostTelegrafsIDOwnersAsyncWithIRestResponse(
            string telegrafID, AddResourceMemberRequestBody addResourceMemberRequestBody, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PostTelegrafsIDOwners");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Telegraf</returns>
        public Telegraf PutTelegrafsID(string telegrafID, TelegrafPluginRequest telegrafPluginRequest,
            string zapTraceSpan = null)
        {
            var localVarResponse = PutTelegrafsIDWithHttpInfo(telegrafID, telegrafPluginRequest, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Telegraf</returns>
        public ApiResponse<Telegraf> PutTelegrafsIDWithHttpInfo(string telegrafID,
            TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PutTelegrafsID");
            }

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

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Update a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Telegraf</returns>
        public async System.Threading.Tasks.Task<RestResponse> PutTelegrafsIDWithIRestResponseAsync(string telegrafID,
            TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PutTelegrafsID");
            }

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

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Telegraf</returns>
        public RestResponse PutTelegrafsIDWithIRestResponse(string telegrafID,
            TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PutTelegrafsID");
            }

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

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Telegraf</returns>
        public RestRequest PutTelegrafsIDWithRestRequest(string telegrafID, TelegrafPluginRequest telegrafPluginRequest,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PutTelegrafsID");
            }

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

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

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

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

        /// <summary>
        /// Update a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Telegraf</returns>
        public async System.Threading.Tasks.Task<Telegraf> PutTelegrafsIDAsync(string telegrafID,
            TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PutTelegrafsIDAsyncWithHttpInfo(telegrafID, telegrafPluginRequest, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Telegraf)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Telegraf>> PutTelegrafsIDAsyncWithHttpInfo(
            string telegrafID, TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PutTelegrafsIDAsyncWithIRestResponse(telegrafID, telegrafPluginRequest, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Update a Telegraf configuration 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="telegrafID">The Telegraf config ID.</param>
        /// <param name="telegrafPluginRequest">Telegraf configuration update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Telegraf)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PutTelegrafsIDAsyncWithIRestResponse(string telegrafID,
            TelegrafPluginRequest telegrafPluginRequest, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'telegrafID' is set
            if (telegrafID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'telegrafID' when calling TelegrafsService->PutTelegrafsID");
            }

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

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

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

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

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

            return localVarResponse;
        }
    }
}