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

        /// <summary>
        /// Add new check
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <returns>Check</returns>
        Check CreateCheck(Check check);

        /// <summary>
        /// Add new check
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <returns>ApiResponse of Check</returns>
        ApiResponse<Check> CreateCheckWithHttpInfo(Check check);

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

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

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

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

        /// <summary>
        /// List all checks
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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>
        /// <returns>Checks</returns>
        Checks GetChecks(string orgID, string zapTraceSpan = null, int? offset = null, int? limit = null);

        /// <summary>
        /// List all checks
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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>
        /// <returns>ApiResponse of Checks</returns>
        ApiResponse<Checks> GetChecksWithHttpInfo(string orgID, string zapTraceSpan = null, int? offset = null,
            int? limit = null);

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

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

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

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

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

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

        /// <summary>
        /// Update a check
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="checkPatch">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Check</returns>
        Check PatchChecksID(string checkID, CheckPatch checkPatch, string zapTraceSpan = null);

        /// <summary>
        /// Update a check
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="checkPatch">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Check</returns>
        ApiResponse<Check> PatchChecksIDWithHttpInfo(string checkID, CheckPatch checkPatch, string zapTraceSpan = null);

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

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

        /// <summary>
        /// Update a check
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="check">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Check</returns>
        Check PutChecksID(string checkID, Check check, string zapTraceSpan = null);

        /// <summary>
        /// Update a check
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="check">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Check</returns>
        ApiResponse<Check> PutChecksIDWithHttpInfo(string checkID, Check check, string zapTraceSpan = null);

        #endregion Synchronous Operations

        #region Asynchronous Operations

        /// <summary>
        /// Add new check
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Check</returns>
        System.Threading.Tasks.Task<Check> CreateCheckAsync(Check check, CancellationToken cancellationToken = default);

        /// <summary>
        /// Add new check
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Check)</returns>
        System.Threading.Tasks.Task<ApiResponse<Check>> CreateCheckAsyncWithHttpInfo(Check check,
            CancellationToken cancellationToken = default);

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

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

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

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

        /// <summary>
        /// List all checks
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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="cancellationToken">Cancellation token</param>
        /// <returns>Task of Checks</returns>
        System.Threading.Tasks.Task<Checks> GetChecksAsync(string orgID, string zapTraceSpan = null, int? offset = null,
            int? limit = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List all checks
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Checks)</returns>
        System.Threading.Tasks.Task<ApiResponse<Checks>> GetChecksAsyncWithHttpInfo(string orgID,
            string zapTraceSpan = null, int? offset = null, int? limit = null,
            CancellationToken cancellationToken = default);

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

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

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

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

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

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

        /// <summary>
        /// Update a check
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="checkPatch">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Check</returns>
        System.Threading.Tasks.Task<Check> PatchChecksIDAsync(string checkID, CheckPatch checkPatch,
            string zapTraceSpan = null, CancellationToken cancellationToken = default);

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

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

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

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

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

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

            ExceptionFactory = Configuration.DefaultExceptionFactory;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ChecksService"/> class
        /// using Configuration object
        /// </summary>
        /// <param name="configuration">An instance of Configuration</param>
        /// <returns></returns>
        public ChecksService(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 new check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <returns>Check</returns>
        public Check CreateCheck(Check check)
        {
            var localVarResponse = CreateCheckWithHttpInfo(check);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add new check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <returns>ApiResponse of Check</returns>
        public ApiResponse<Check> CreateCheckWithHttpInfo(Check check)
        {
            // verify the required parameter 'check' is set
            if (check == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'check' when calling ChecksService->CreateCheck");
            }

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (check != null && check.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(check); // http body (model) parameter
            }
            else
            {
                localVarPostBody = check; // 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("CreateCheck", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

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

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (check != null && check.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(check); // http body (model) parameter
            }
            else
            {
                localVarPostBody = check; // 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("CreateCheck", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Add new check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <returns>ApiResponse of Check</returns>
        public RestResponse CreateCheckWithIRestResponse(Check check)
        {
            // verify the required parameter 'check' is set
            if (check == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'check' when calling ChecksService->CreateCheck");
            }

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (check != null && check.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(check); // http body (model) parameter
            }
            else
            {
                localVarPostBody = check; // 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("CreateCheck", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Add new check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <returns>ApiResponse of Check</returns>
        public RestRequest CreateCheckWithRestRequest(Check check)
        {
            // verify the required parameter 'check' is set
            if (check == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'check' when calling ChecksService->CreateCheck");
            }

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (check != null && check.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(check); // http body (model) parameter
            }
            else
            {
                localVarPostBody = check; // 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 new check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Check</returns>
        public async System.Threading.Tasks.Task<Check> CreateCheckAsync(Check check,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse = await CreateCheckAsyncWithHttpInfo(check, cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Add new check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="check">Check to create</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Check)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Check>> CreateCheckAsyncWithHttpInfo(Check check,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await CreateCheckAsyncWithIRestResponse(check, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (check != null && check.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(check); // http body (model) parameter
            }
            else
            {
                localVarPostBody = check; // 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("CreateCheck", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("DeleteChecksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("DeleteChecksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("DeleteChecksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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 check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check 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 DeleteChecksIDAsync(string checkID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            return DeleteChecksIDAsyncWithHttpInfo(checkID, zapTraceSpan, cancellationToken);
        }

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("DeleteChecksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Delete label from a check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check 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 DeleteChecksIDLabelsID(string checkID, string labelID, string zapTraceSpan = null)
        {
            DeleteChecksIDLabelsIDWithHttpInfo(checkID, labelID, zapTraceSpan);
        }

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

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

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

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

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

            return localVarResponse;
        }

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

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

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

            return localVarResponse;
        }

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

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// List all checks 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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>
        /// <returns>Checks</returns>
        public Checks GetChecks(string orgID, string zapTraceSpan = null, int? offset = null, int? limit = null)
        {
            var localVarResponse = GetChecksWithHttpInfo(orgID, zapTraceSpan, offset, limit);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all checks 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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>
        /// <returns>ApiResponse of Checks</returns>
        public ApiResponse<Checks> GetChecksWithHttpInfo(string orgID, string zapTraceSpan = null, int? offset = null,
            int? limit = null)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400, "Missing required parameter 'orgID' when calling ChecksService->GetChecks");
            }

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (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("GetChecks", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// List all checks 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Checks</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetChecksWithIRestResponseAsync(string orgID,
            string zapTraceSpan = null, int? offset = null, int? limit = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400, "Missing required parameter 'orgID' when calling ChecksService->GetChecks");
            }

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (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("GetChecks", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all checks 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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>
        /// <returns>ApiResponse of Checks</returns>
        public RestResponse GetChecksWithIRestResponse(string orgID, string zapTraceSpan = null, int? offset = null,
            int? limit = null)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400, "Missing required parameter 'orgID' when calling ChecksService->GetChecks");
            }

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (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("GetChecks", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// List all checks 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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>
        /// <returns>ApiResponse of Checks</returns>
        public RestRequest GetChecksWithRestRequest(string orgID, string zapTraceSpan = null, int? offset = null,
            int? limit = null)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400, "Missing required parameter 'orgID' when calling ChecksService->GetChecks");
            }

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (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 checks 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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="cancellationToken">Cancellation token</param>
        /// <returns>Task of Checks</returns>
        public async System.Threading.Tasks.Task<Checks> GetChecksAsync(string orgID, string zapTraceSpan = null,
            int? offset = null, int? limit = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await GetChecksAsyncWithHttpInfo(orgID, zapTraceSpan, offset, limit, cancellationToken)
                    .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List all checks 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Checks)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Checks>> GetChecksAsyncWithHttpInfo(string orgID,
            string zapTraceSpan = null, int? offset = null, int? limit = null,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await GetChecksAsyncWithIRestResponse(orgID, zapTraceSpan, offset, limit, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List all checks 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">Only show checks 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="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Checks)</returns>
        public async System.Threading.Tasks.Task<RestResponse> GetChecksAsyncWithIRestResponse(string orgID,
            string zapTraceSpan = null, int? offset = null, int? limit = null,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400, "Missing required parameter 'orgID' when calling ChecksService->GetChecks");
            }

            var localVarPath = "/api/v2/checks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (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("GetChecks", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("GetChecksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("GetChecksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("GetChecksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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 check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Check</returns>
        public async System.Threading.Tasks.Task<Check> GetChecksIDAsync(string checkID, string zapTraceSpan = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse = await GetChecksIDAsyncWithHttpInfo(checkID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("GetChecksID", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

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

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

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

            return localVarResponse;
        }

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

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

            return localVarResponse;
        }

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/checks/{checkID}/query";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("GetChecksIDQuery", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

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

            var localVarPath = "/api/v2/checks/{checkID}/query";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("GetChecksIDQuery", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/checks/{checkID}/query";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("GetChecksIDQuery", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

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

            var localVarPath = "/api/v2/checks/{checkID}/query";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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 check query 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of FluxResponse</returns>
        public async System.Threading.Tasks.Task<FluxResponse> GetChecksIDQueryAsync(string checkID,
            string zapTraceSpan = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await GetChecksIDQueryAsyncWithHttpInfo(checkID, zapTraceSpan, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

            var localVarPath = "/api/v2/checks/{checkID}/query";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // 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("GetChecksIDQuery", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Update a check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="checkPatch">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Check</returns>
        public Check PatchChecksID(string checkID, CheckPatch checkPatch, string zapTraceSpan = null)
        {
            var localVarResponse = PatchChecksIDWithHttpInfo(checkID, checkPatch, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="checkPatch">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Check</returns>
        public ApiResponse<Check> PatchChecksIDWithHttpInfo(string checkID, CheckPatch checkPatch,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'checkID' is set
            if (checkID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'checkID' when calling ChecksService->PatchChecksID");
            }

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

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

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="checkPatch">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Check</returns>
        public RestResponse PatchChecksIDWithIRestResponse(string checkID, CheckPatch checkPatch,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'checkID' is set
            if (checkID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'checkID' when calling ChecksService->PatchChecksID");
            }

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="checkPatch">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Check</returns>
        public RestRequest PatchChecksIDWithRestRequest(string checkID, CheckPatch checkPatch,
            string zapTraceSpan = null)
        {
            // verify the required parameter 'checkID' is set
            if (checkID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'checkID' when calling ChecksService->PatchChecksID");
            }

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

            return localVarResponse;
        }

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

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

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

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

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

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

            return localVarResponse;
        }

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

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

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

            return localVarResponse;
        }

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

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="check">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>Check</returns>
        public Check PutChecksID(string checkID, Check check, string zapTraceSpan = null)
        {
            var localVarResponse = PutChecksIDWithHttpInfo(checkID, check, zapTraceSpan);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a check 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="checkID">The check ID.</param>
        /// <param name="check">Check update to apply</param>
        /// <param name="zapTraceSpan">OpenTracing span context (optional)</param>
        /// <returns>ApiResponse of Check</returns>
        public ApiResponse<Check> PutChecksIDWithHttpInfo(string checkID, Check check, string zapTraceSpan = null)
        {
            // verify the required parameter 'checkID' is set
            if (checkID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'checkID' when calling ChecksService->PutChecksID");
            }

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

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

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

            return localVarResponse;
        }

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

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

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

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

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

            var localVarPath = "/api/v2/checks/{checkID}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (checkID != null)
            {
                localVarPathParams.Add("checkID", Configuration.ApiClient.ParameterToString(checkID)); // path parameter
            }

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

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

            return localVarResponse;
        }
    }
}