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

        /// <summary>
        /// Add a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <returns>NotificationRule</returns>
        NotificationRule CreateNotificationRule(NotificationRule notificationRule);

        /// <summary>
        /// Add a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        ApiResponse<NotificationRule> CreateNotificationRuleWithHttpInfo(NotificationRule notificationRule);

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

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

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

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

        /// <summary>
        /// List all notification rules
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <returns>NotificationRules</returns>
        NotificationRules GetNotificationRules(string orgID, string zapTraceSpan = null, int? offset = null,
            int? limit = null, string checkID = null, string tag = null);

        /// <summary>
        /// List all notification rules
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <returns>ApiResponse of NotificationRules</returns>
        ApiResponse<NotificationRules> GetNotificationRulesWithHttpInfo(string orgID, string zapTraceSpan = null,
            int? offset = null, int? limit = null, string checkID = null, string tag = null);

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

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

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

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

        /// <summary>
        /// Update a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>NotificationRule</returns>
        NotificationRule PatchNotificationRulesID(string ruleID, NotificationRuleUpdate notificationRuleUpdate,
            string zapTraceSpan = null);

        /// <summary>
        /// Update a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        ApiResponse<NotificationRule> PatchNotificationRulesIDWithHttpInfo(string ruleID,
            NotificationRuleUpdate notificationRuleUpdate, string zapTraceSpan = null);

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

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

        /// <summary>
        /// Update a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>NotificationRule</returns>
        NotificationRule PutNotificationRulesID(string ruleID, NotificationRule notificationRule,
            string zapTraceSpan = null);

        /// <summary>
        /// Update a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        ApiResponse<NotificationRule> PutNotificationRulesIDWithHttpInfo(string ruleID,
            NotificationRule notificationRule, string zapTraceSpan = null);

        #endregion Synchronous Operations

        #region Asynchronous Operations

        /// <summary>
        /// Add a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of NotificationRule</returns>
        System.Threading.Tasks.Task<NotificationRule> CreateNotificationRuleAsync(NotificationRule notificationRule,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Add a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (NotificationRule)</returns>
        System.Threading.Tasks.Task<ApiResponse<NotificationRule>> CreateNotificationRuleAsyncWithHttpInfo(
            NotificationRule notificationRule, CancellationToken cancellationToken = default);

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

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

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

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

        /// <summary>
        /// List all notification rules
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of NotificationRules</returns>
        System.Threading.Tasks.Task<NotificationRules> GetNotificationRulesAsync(string orgID,
            string zapTraceSpan = null, int? offset = null, int? limit = null, string checkID = null, string tag = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// List all notification rules
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (NotificationRules)</returns>
        System.Threading.Tasks.Task<ApiResponse<NotificationRules>> GetNotificationRulesAsyncWithHttpInfo(string orgID,
            string zapTraceSpan = null, int? offset = null, int? limit = null, string checkID = null, string tag = null,
            CancellationToken cancellationToken = default);

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

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

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

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

        /// <summary>
        /// Update a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of NotificationRule</returns>
        System.Threading.Tasks.Task<NotificationRule> PatchNotificationRulesIDAsync(string ruleID,
            NotificationRuleUpdate notificationRuleUpdate, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (NotificationRule)</returns>
        System.Threading.Tasks.Task<ApiResponse<NotificationRule>> PatchNotificationRulesIDAsyncWithHttpInfo(
            string ruleID, NotificationRuleUpdate notificationRuleUpdate, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

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

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

        /// <summary>
        /// Update a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of NotificationRule</returns>
        System.Threading.Tasks.Task<NotificationRule> PutNotificationRulesIDAsync(string ruleID,
            NotificationRule notificationRule, string zapTraceSpan = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a notification rule
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (NotificationRule)</returns>
        System.Threading.Tasks.Task<ApiResponse<NotificationRule>> PutNotificationRulesIDAsyncWithHttpInfo(
            string ruleID, NotificationRule notificationRule, 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 NotificationRulesService : INotificationRulesService
    {
        private ExceptionFactory _exceptionFactory = (name, response) => null;

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

            ExceptionFactory = Configuration.DefaultExceptionFactory;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="NotificationRulesService"/> class
        /// using Configuration object
        /// </summary>
        /// <param name="configuration">An instance of Configuration</param>
        /// <returns></returns>
        public NotificationRulesService(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>
        /// Add a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <returns>NotificationRule</returns>
        public NotificationRule CreateNotificationRule(NotificationRule notificationRule)
        {
            var localVarResponse = CreateNotificationRuleWithHttpInfo(notificationRule);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public ApiResponse<NotificationRule> CreateNotificationRuleWithHttpInfo(NotificationRule notificationRule)
        {
            // verify the required parameter 'notificationRule' is set
            if (notificationRule == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'notificationRule' when calling NotificationRulesService->CreateNotificationRule");
            }

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

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

        /// <summary>
        /// Add a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public async System.Threading.Tasks.Task<RestResponse> CreateNotificationRuleWithIRestResponseAsync(
            NotificationRule notificationRule, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'notificationRule' is set
            if (notificationRule == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'notificationRule' when calling NotificationRulesService->CreateNotificationRule");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public RestResponse CreateNotificationRuleWithIRestResponse(NotificationRule notificationRule)
        {
            // verify the required parameter 'notificationRule' is set
            if (notificationRule == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'notificationRule' when calling NotificationRulesService->CreateNotificationRule");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// Add a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public RestRequest CreateNotificationRuleWithRestRequest(NotificationRule notificationRule)
        {
            // verify the required parameter 'notificationRule' is set
            if (notificationRule == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'notificationRule' when calling NotificationRulesService->CreateNotificationRule");
            }

            var localVarPath = "/api/v2/notificationRules";
            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 (notificationRule != null && notificationRule.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(notificationRule); // http body (model) parameter
            }
            else
            {
                localVarPostBody = notificationRule; // 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 notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of NotificationRule</returns>
        public async System.Threading.Tasks.Task<NotificationRule> CreateNotificationRuleAsync(
            NotificationRule notificationRule, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await CreateNotificationRuleAsyncWithHttpInfo(notificationRule, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (NotificationRule)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<NotificationRule>> CreateNotificationRuleAsyncWithHttpInfo(
            NotificationRule notificationRule, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await CreateNotificationRuleAsyncWithIRestResponse(notificationRule, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Add a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="notificationRule">Notification rule to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (NotificationRule)</returns>
        public async System.Threading.Tasks.Task<RestResponse> CreateNotificationRuleAsyncWithIRestResponse(
            NotificationRule notificationRule, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'notificationRule' is set
            if (notificationRule == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'notificationRule' when calling NotificationRulesService->CreateNotificationRule");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// Delete a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteNotificationRulesID(string ruleID, string zapTraceSpan = null)
        {
            DeleteNotificationRulesIDWithHttpInfo(ruleID, zapTraceSpan);
        }

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

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

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

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

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

            return localVarResponse;
        }

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

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

            return localVarResponse;
        }

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Delete label from a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="labelID">The ID of the label to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns></returns>
        public void DeleteNotificationRulesIDLabelsID(string ruleID, string labelID, string zapTraceSpan = null)
        {
            DeleteNotificationRulesIDLabelsIDWithHttpInfo(ruleID, labelID, zapTraceSpan);
        }

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

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

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

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

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

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

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

            return localVarResponse;
        }

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

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

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

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/notificationRules/{ruleID}/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 (ruleID != null)
            {
                localVarPathParams.Add("ruleID", Configuration.ApiClient.ParameterToString(ruleID)); // 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 label from a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="labelID">The ID of the label to delete.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        public System.Threading.Tasks.Task DeleteNotificationRulesIDLabelsIDAsync(string ruleID, string labelID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            return DeleteNotificationRulesIDLabelsIDAsyncWithHttpInfo(ruleID, labelID, zapTraceSpan, cancellationToken);
        }

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// List all notification rules 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <returns>NotificationRules</returns>
        public NotificationRules GetNotificationRules(string orgID, string zapTraceSpan = null, int? offset = null,
            int? limit = null, string checkID = null, string tag = null)
        {
            var localVarResponse = GetNotificationRulesWithHttpInfo(orgID, zapTraceSpan, offset, limit, checkID, tag);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all notification rules 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <returns>ApiResponse of NotificationRules</returns>
        public ApiResponse<NotificationRules> GetNotificationRulesWithHttpInfo(string orgID, string zapTraceSpan = null,
            int? offset = null, int? limit = null, string checkID = null, string tag = null)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling NotificationRulesService->GetNotificationRules");
            }

            var localVarPath = "/api/v2/notificationRules";
            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 (offset != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "offset", offset)); // query parameter
            }

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

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

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

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

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

        /// <summary>
        /// List all notification rules 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of NotificationRules</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetNotificationRulesWithIRestResponseAsync(string orgID,
            string zapTraceSpan = null, int? offset = null, int? limit = null, string checkID = null, string tag = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling NotificationRulesService->GetNotificationRules");
            }

            var localVarPath = "/api/v2/notificationRules";
            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 (offset != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "offset", offset)); // query parameter
            }

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

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// List all notification rules 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <returns>ApiResponse of NotificationRules</returns>
        public RestResponse GetNotificationRulesWithIRestResponse(string orgID, string zapTraceSpan = null,
            int? offset = null, int? limit = null, string checkID = null, string tag = null)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling NotificationRulesService->GetNotificationRules");
            }

            var localVarPath = "/api/v2/notificationRules";
            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 (offset != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "offset", offset)); // query parameter
            }

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

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// List all notification rules 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <returns>ApiResponse of NotificationRules</returns>
        public RestRequest GetNotificationRulesWithRestRequest(string orgID, string zapTraceSpan = null,
            int? offset = null, int? limit = null, string checkID = null, string tag = null)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling NotificationRulesService->GetNotificationRules");
            }

            var localVarPath = "/api/v2/notificationRules";
            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 (offset != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "offset", offset)); // query parameter
            }

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

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

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

            if (tag != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "tag", tag)); // 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 notification rules 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of NotificationRules</returns>
        public async System.Threading.Tasks.Task<NotificationRules> GetNotificationRulesAsync(string orgID,
            string zapTraceSpan = null, int? offset = null, int? limit = null, string checkID = null, string tag = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetNotificationRulesAsyncWithHttpInfo(orgID, zapTraceSpan, offset, limit, checkID, tag,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all notification rules 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (NotificationRules)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<NotificationRules>> GetNotificationRulesAsyncWithHttpInfo(
            string orgID, string zapTraceSpan = null, int? offset = null, int? limit = null, string checkID = null,
            string tag = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetNotificationRulesAsyncWithIRestResponse(orgID, zapTraceSpan, offset, limit, checkID, tag,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List all notification rules 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show notification rules that belong to a specific organization ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="offset"> (optional)</param>
        /// <param name="limit"> (optional, default to 20)</param>
        /// <param name="checkID">Only show notifications that belong to the specific check ID. (optional)</param>
        /// <param name="tag">Only return notification rules that \&quot;would match\&quot; statuses which contain the tag key value pairs provided. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (NotificationRules)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetNotificationRulesAsyncWithIRestResponse(string orgID,
            string zapTraceSpan = null, int? offset = null, int? limit = null, string checkID = null, string tag = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling NotificationRulesService->GetNotificationRules");
            }

            var localVarPath = "/api/v2/notificationRules";
            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 (offset != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "offset", offset)); // query parameter
            }

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

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

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

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

            return localVarResponse;
        }

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

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

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

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

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

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

            return localVarResponse;
        }

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

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

            return localVarResponse;
        }

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

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

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

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

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


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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

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

            return localVarResponse;
        }

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

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

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

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

            return localVarResponse;
        }

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

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

            return localVarResponse;
        }

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>NotificationRule</returns>
        public NotificationRule PatchNotificationRulesID(string ruleID, NotificationRuleUpdate notificationRuleUpdate,
            string zapTraceSpan = null)
        {
            var localVarResponse = PatchNotificationRulesIDWithHttpInfo(ruleID, notificationRuleUpdate, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public ApiResponse<NotificationRule> PatchNotificationRulesIDWithHttpInfo(string ruleID,
            NotificationRuleUpdate notificationRuleUpdate, string zapTraceSpan = null)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PatchNotificationRulesID");
            }

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

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

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

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

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

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


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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public async System.Threading.Tasks.Task<RestResponse> PatchNotificationRulesIDWithIRestResponseAsync(
            string ruleID, NotificationRuleUpdate notificationRuleUpdate, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PatchNotificationRulesID");
            }

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

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

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

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

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

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


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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public RestResponse PatchNotificationRulesIDWithIRestResponse(string ruleID,
            NotificationRuleUpdate notificationRuleUpdate, string zapTraceSpan = null)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PatchNotificationRulesID");
            }

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

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

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

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

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

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


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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public RestRequest PatchNotificationRulesIDWithRestRequest(string ruleID,
            NotificationRuleUpdate notificationRuleUpdate, string zapTraceSpan = null)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PatchNotificationRulesID");
            }

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

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

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

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

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

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


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

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of NotificationRule</returns>
        public async System.Threading.Tasks.Task<NotificationRule> PatchNotificationRulesIDAsync(string ruleID,
            NotificationRuleUpdate notificationRuleUpdate, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PatchNotificationRulesIDAsyncWithHttpInfo(ruleID, notificationRuleUpdate, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (NotificationRule)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<NotificationRule>>
            PatchNotificationRulesIDAsyncWithHttpInfo(string ruleID, NotificationRuleUpdate notificationRuleUpdate,
                string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PatchNotificationRulesIDAsyncWithIRestResponse(ruleID, notificationRuleUpdate, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRuleUpdate">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (NotificationRule)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PatchNotificationRulesIDAsyncWithIRestResponse(
            string ruleID, NotificationRuleUpdate notificationRuleUpdate, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PatchNotificationRulesID");
            }

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

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

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

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

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

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


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

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

            return localVarResponse;
        }

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

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

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

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

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

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

            return localVarResponse;
        }

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

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

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

            return localVarResponse;
        }

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

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>NotificationRule</returns>
        public NotificationRule PutNotificationRulesID(string ruleID, NotificationRule notificationRule,
            string zapTraceSpan = null)
        {
            var localVarResponse = PutNotificationRulesIDWithHttpInfo(ruleID, notificationRule, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public ApiResponse<NotificationRule> PutNotificationRulesIDWithHttpInfo(string ruleID,
            NotificationRule notificationRule, string zapTraceSpan = null)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PutNotificationRulesID");
            }

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

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

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

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

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

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public async System.Threading.Tasks.Task<RestResponse> PutNotificationRulesIDWithIRestResponseAsync(
            string ruleID, NotificationRule notificationRule, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PutNotificationRulesID");
            }

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

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public RestResponse PutNotificationRulesIDWithIRestResponse(string ruleID, NotificationRule notificationRule,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PutNotificationRulesID");
            }

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

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of NotificationRule</returns>
        public RestRequest PutNotificationRulesIDWithRestRequest(string ruleID, NotificationRule notificationRule,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PutNotificationRulesID");
            }

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

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

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

            if (notificationRule != null && notificationRule.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(notificationRule); // http body (model) parameter
            }
            else
            {
                localVarPostBody = notificationRule; // 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 notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of NotificationRule</returns>
        public async System.Threading.Tasks.Task<NotificationRule> PutNotificationRulesIDAsync(string ruleID,
            NotificationRule notificationRule, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await PutNotificationRulesIDAsyncWithHttpInfo(ruleID, notificationRule, zapTraceSpan, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (NotificationRule)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<NotificationRule>> PutNotificationRulesIDAsyncWithHttpInfo(
            string ruleID, NotificationRule notificationRule, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await PutNotificationRulesIDAsyncWithIRestResponse(ruleID, notificationRule, zapTraceSpan,
                    cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Update a notification rule 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="ruleID">The notification rule ID.</param>
        /// <param name="notificationRule">Notification rule update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (NotificationRule)</returns>
        public async System.Threading.Tasks.Task<RestResponse> PutNotificationRulesIDAsyncWithIRestResponse(
            string ruleID, NotificationRule notificationRule, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'ruleID' is set
            if (ruleID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'ruleID' when calling NotificationRulesService->PutNotificationRulesID");
            }

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

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

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

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

            return localVarResponse;
        }
    }
}