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

        /// <summary>
        /// Apply or dry-run a template
        /// </summary>
        /// <remarks>
        /// Applies or performs a dry-run of template in an organization.
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <returns>TemplateSummary</returns>
        TemplateSummary ApplyTemplate(TemplateApply templateApply);

        /// <summary>
        /// Apply or dry-run a template
        /// </summary>
        /// <remarks>
        /// Applies or performs a dry-run of template in an organization.
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <returns>ApiResponse of TemplateSummary</returns>
        ApiResponse<TemplateSummary> ApplyTemplateWithHttpInfo(TemplateApply templateApply);

        /// <summary>
        /// Create a new stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <returns>Stack</returns>
        Stack CreateStack(PostStackRequest postStackRequest = null);

        /// <summary>
        /// Create a new stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <returns>ApiResponse of Stack</returns>
        ApiResponse<Stack> CreateStackWithHttpInfo(PostStackRequest postStackRequest = null);

        /// <summary>
        /// Delete a stack and associated resources
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <returns></returns>
        void DeleteStack(string stackId, string orgID);

        /// <summary>
        /// Delete a stack and associated resources
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <returns>ApiResponse of Object(void)</returns>
        ApiResponse<object> DeleteStackWithHttpInfo(string stackId, string orgID);

        /// <summary>
        /// Export a new template
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <returns>List&lt;Object&gt;</returns>
        List<object> ExportTemplate(TemplateExportByID templateExportByID = null);

        /// <summary>
        /// Export a new template
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <returns>ApiResponse of List&lt;Object&gt;</returns>
        ApiResponse<List<object>> ExportTemplateWithHttpInfo(TemplateExportByID templateExportByID = null);

        /// <summary>
        /// List installed templates
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <returns>ListStacksResponse</returns>
        ListStacksResponse ListStacks(string orgID, string name = null, string stackID = null);

        /// <summary>
        /// List installed templates
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <returns>ApiResponse of ListStacksResponse</returns>
        ApiResponse<ListStacksResponse> ListStacksWithHttpInfo(string orgID, string name = null, string stackID = null);

        /// <summary>
        /// Retrieve a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>Stack</returns>
        Stack ReadStack(string stackId);

        /// <summary>
        /// Retrieve a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>ApiResponse of Stack</returns>
        ApiResponse<Stack> ReadStackWithHttpInfo(string stackId);

        /// <summary>
        /// Uninstall a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>Stack</returns>
        Stack UninstallStack(string stackId);

        /// <summary>
        /// Uninstall a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>ApiResponse of Stack</returns>
        ApiResponse<Stack> UninstallStackWithHttpInfo(string stackId);

        /// <summary>
        /// Update a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <returns>Stack</returns>
        Stack UpdateStack(string stackId, PatchStackRequest patchStackRequest = null);

        /// <summary>
        /// Update a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <returns>ApiResponse of Stack</returns>
        ApiResponse<Stack> UpdateStackWithHttpInfo(string stackId, PatchStackRequest patchStackRequest = null);

        #endregion Synchronous Operations

        #region Asynchronous Operations

        /// <summary>
        /// Apply or dry-run a template
        /// </summary>
        /// <remarks>
        /// Applies or performs a dry-run of template in an organization.
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of TemplateSummary</returns>
        System.Threading.Tasks.Task<TemplateSummary> ApplyTemplateAsync(TemplateApply templateApply,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Apply or dry-run a template
        /// </summary>
        /// <remarks>
        /// Applies or performs a dry-run of template in an organization.
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (TemplateSummary)</returns>
        System.Threading.Tasks.Task<ApiResponse<TemplateSummary>> ApplyTemplateAsyncWithHttpInfo(
            TemplateApply templateApply, CancellationToken cancellationToken = default);

        /// <summary>
        /// Create a new stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Stack</returns>
        System.Threading.Tasks.Task<Stack> CreateStackAsync(PostStackRequest postStackRequest = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Create a new stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Stack)</returns>
        System.Threading.Tasks.Task<ApiResponse<Stack>> CreateStackAsyncWithHttpInfo(
            PostStackRequest postStackRequest = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Delete a stack and associated resources
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        System.Threading.Tasks.Task DeleteStackAsync(string stackId, string orgID,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Delete a stack and associated resources
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        System.Threading.Tasks.Task<ApiResponse<object>> DeleteStackAsyncWithHttpInfo(string stackId, string orgID,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Export a new template
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of List&lt;Object&gt;</returns>
        System.Threading.Tasks.Task<List<object>> ExportTemplateAsync(TemplateExportByID templateExportByID = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Export a new template
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (List&lt;Object&gt;)</returns>
        System.Threading.Tasks.Task<ApiResponse<List<object>>> ExportTemplateAsyncWithHttpInfo(
            TemplateExportByID templateExportByID = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List installed templates
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ListStacksResponse</returns>
        System.Threading.Tasks.Task<ListStacksResponse> ListStacksAsync(string orgID, string name = null,
            string stackID = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// List installed templates
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ListStacksResponse)</returns>
        System.Threading.Tasks.Task<ApiResponse<ListStacksResponse>> ListStacksAsyncWithHttpInfo(string orgID,
            string name = null, string stackID = null, CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Stack</returns>
        System.Threading.Tasks.Task<Stack>
            ReadStackAsync(string stackId, CancellationToken cancellationToken = default);

        /// <summary>
        /// Retrieve a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Stack)</returns>
        System.Threading.Tasks.Task<ApiResponse<Stack>> ReadStackAsyncWithHttpInfo(string stackId,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Uninstall a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Stack</returns>
        System.Threading.Tasks.Task<Stack> UninstallStackAsync(string stackId,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Uninstall a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Stack)</returns>
        System.Threading.Tasks.Task<ApiResponse<Stack>> UninstallStackAsyncWithHttpInfo(string stackId,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Stack</returns>
        System.Threading.Tasks.Task<Stack> UpdateStackAsync(string stackId, PatchStackRequest patchStackRequest = null,
            CancellationToken cancellationToken = default);

        /// <summary>
        /// Update a stack
        /// </summary>
        /// <remarks>
        /// 
        /// </remarks>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Stack)</returns>
        System.Threading.Tasks.Task<ApiResponse<Stack>> UpdateStackAsyncWithHttpInfo(string stackId,
            PatchStackRequest patchStackRequest = null, CancellationToken cancellationToken = default);

        #endregion Asynchronous Operations
    }

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

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

            ExceptionFactory = Configuration.DefaultExceptionFactory;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="TemplatesService"/> class
        /// using Configuration object
        /// </summary>
        /// <param name="configuration">An instance of Configuration</param>
        /// <returns></returns>
        public TemplatesService(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>
        /// Apply or dry-run a template Applies or performs a dry-run of template in an organization.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <returns>TemplateSummary</returns>
        public TemplateSummary ApplyTemplate(TemplateApply templateApply)
        {
            var localVarResponse = ApplyTemplateWithHttpInfo(templateApply);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Apply or dry-run a template Applies or performs a dry-run of template in an organization.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <returns>ApiResponse of TemplateSummary</returns>
        public ApiResponse<TemplateSummary> ApplyTemplateWithHttpInfo(TemplateApply templateApply)
        {
            // verify the required parameter 'templateApply' is set
            if (templateApply == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'templateApply' when calling TemplatesService->ApplyTemplate");
            }

            var localVarPath = "/api/v2/templates/apply";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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",
                "application/x-jsonnet",
                "text/yml"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

        /// <summary>
        /// Apply or dry-run a template Applies or performs a dry-run of template in an organization.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of TemplateSummary</returns>
        public async System.Threading.Tasks.Task<RestResponse> ApplyTemplateWithIRestResponseAsync(
            TemplateApply templateApply, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'templateApply' is set
            if (templateApply == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'templateApply' when calling TemplatesService->ApplyTemplate");
            }

            var localVarPath = "/api/v2/templates/apply";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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",
                "application/x-jsonnet",
                "text/yml"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

            return localVarResponse;
        }

        /// <summary>
        /// Apply or dry-run a template Applies or performs a dry-run of template in an organization.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <returns>ApiResponse of TemplateSummary</returns>
        public RestResponse ApplyTemplateWithIRestResponse(TemplateApply templateApply)
        {
            // verify the required parameter 'templateApply' is set
            if (templateApply == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'templateApply' when calling TemplatesService->ApplyTemplate");
            }

            var localVarPath = "/api/v2/templates/apply";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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",
                "application/x-jsonnet",
                "text/yml"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

            return localVarResponse;
        }

        /// <summary>
        /// Apply or dry-run a template Applies or performs a dry-run of template in an organization.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <returns>ApiResponse of TemplateSummary</returns>
        public RestRequest ApplyTemplateWithRestRequest(TemplateApply templateApply)
        {
            // verify the required parameter 'templateApply' is set
            if (templateApply == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'templateApply' when calling TemplatesService->ApplyTemplate");
            }

            var localVarPath = "/api/v2/templates/apply";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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",
                "application/x-jsonnet",
                "text/yml"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

            if (templateApply != null && templateApply.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(templateApply); // http body (model) parameter
            }
            else
            {
                localVarPostBody = templateApply; // 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>
        /// Apply or dry-run a template Applies or performs a dry-run of template in an organization.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of TemplateSummary</returns>
        public async System.Threading.Tasks.Task<TemplateSummary> ApplyTemplateAsync(TemplateApply templateApply,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await ApplyTemplateAsyncWithHttpInfo(templateApply, cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Apply or dry-run a template Applies or performs a dry-run of template in an organization.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (TemplateSummary)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<TemplateSummary>> ApplyTemplateAsyncWithHttpInfo(
            TemplateApply templateApply, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await ApplyTemplateAsyncWithIRestResponse(templateApply, cancellationToken)
                .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Apply or dry-run a template Applies or performs a dry-run of template in an organization.
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateApply"></param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (TemplateSummary)</returns>
        public async System.Threading.Tasks.Task<RestResponse> ApplyTemplateAsyncWithIRestResponse(
            TemplateApply templateApply, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'templateApply' is set
            if (templateApply == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'templateApply' when calling TemplatesService->ApplyTemplate");
            }

            var localVarPath = "/api/v2/templates/apply";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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",
                "application/x-jsonnet",
                "text/yml"
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

            return localVarResponse;
        }

        /// <summary>
        /// Create a new stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <returns>Stack</returns>
        public Stack CreateStack(PostStackRequest postStackRequest = null)
        {
            var localVarResponse = CreateStackWithHttpInfo(postStackRequest);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Create a new stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <returns>ApiResponse of Stack</returns>
        public ApiResponse<Stack> CreateStackWithHttpInfo(PostStackRequest postStackRequest = null)
        {
            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (postStackRequest != null && postStackRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(postStackRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = postStackRequest; // 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("CreateStack", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

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

        /// <summary>
        /// Create a new stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Stack</returns>
        public async System.Threading.Tasks.Task<RestResponse> CreateStackWithIRestResponseAsync(
            PostStackRequest postStackRequest = null, CancellationToken cancellationToken = default)
        {
            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (postStackRequest != null && postStackRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(postStackRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = postStackRequest; // 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("CreateStack", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Create a new stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <returns>ApiResponse of Stack</returns>
        public RestResponse CreateStackWithIRestResponse(PostStackRequest postStackRequest = null)
        {
            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (postStackRequest != null && postStackRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(postStackRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = postStackRequest; // 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("CreateStack", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Create a new stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <returns>ApiResponse of Stack</returns>
        public RestRequest CreateStackWithRestRequest(PostStackRequest postStackRequest = null)
        {
            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (postStackRequest != null && postStackRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(postStackRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = postStackRequest; // byte array
            }

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

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


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

        /// <summary>
        /// Create a new stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Stack</returns>
        public async System.Threading.Tasks.Task<Stack> CreateStackAsync(PostStackRequest postStackRequest = null,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse = await CreateStackAsyncWithHttpInfo(postStackRequest, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Create a new stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Stack)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Stack>> CreateStackAsyncWithHttpInfo(
            PostStackRequest postStackRequest = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await CreateStackAsyncWithIRestResponse(postStackRequest, cancellationToken)
                .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Create a new stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="postStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Stack)</returns>
        public async System.Threading.Tasks.Task<RestResponse> CreateStackAsyncWithIRestResponse(
            PostStackRequest postStackRequest = null, CancellationToken cancellationToken = default)
        {
            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (postStackRequest != null && postStackRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(postStackRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = postStackRequest; // 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("CreateStack", localVarResponse);
                if (exception != null)
                {
                    throw exception;
                }
            }

            return localVarResponse;
        }

        /// <summary>
        /// Delete a stack and associated resources 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <returns></returns>
        public void DeleteStack(string stackId, string orgID)
        {
            DeleteStackWithHttpInfo(stackId, orgID);
        }

        /// <summary>
        /// Delete a stack and associated resources 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public ApiResponse<object> DeleteStackWithHttpInfo(string stackId, string orgID)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->DeleteStack");
            }

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

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

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

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

        /// <summary>
        /// Delete a stack and associated resources 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public async System.Threading.Tasks.Task<RestResponse> DeleteStackWithIRestResponseAsync(string stackId,
            string orgID, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->DeleteStack");
            }

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Delete a stack and associated resources 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestResponse DeleteStackWithIRestResponse(string stackId, string orgID)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->DeleteStack");
            }

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Delete a stack and associated resources 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <returns>ApiResponse of Object(void)</returns>
        public RestRequest DeleteStackWithRestRequest(string stackId, string orgID)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->DeleteStack");
            }

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

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

            if (orgID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "orgID", orgID)); // query 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 stack and associated resources 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of void</returns>
        public System.Threading.Tasks.Task DeleteStackAsync(string stackId, string orgID,
            CancellationToken cancellationToken = default)
        {
            return DeleteStackAsyncWithHttpInfo(stackId, orgID, cancellationToken);
        }

        /// <summary>
        /// Delete a stack and associated resources 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse</returns>
        public async System.Threading.Tasks.Task<ApiResponse<object>> DeleteStackAsyncWithHttpInfo(string stackId,
            string orgID, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await DeleteStackAsyncWithIRestResponse(stackId, orgID, cancellationToken)
                .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Delete a stack and associated resources 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="orgID">The identifier of the organization.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse</returns>
        public async System.Threading.Tasks.Task<RestResponse> DeleteStackAsyncWithIRestResponse(string stackId,
            string orgID, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->DeleteStack");
            }

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Export a new template 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <returns>List&lt;Object&gt;</returns>
        public List<object> ExportTemplate(TemplateExportByID templateExportByID = null)
        {
            var localVarResponse = ExportTemplateWithHttpInfo(templateExportByID);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Export a new template 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <returns>ApiResponse of List&lt;Object&gt;</returns>
        public ApiResponse<List<object>> ExportTemplateWithHttpInfo(TemplateExportByID templateExportByID = null)
        {
            var localVarPath = "/api/v2/templates/export";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (templateExportByID != null && templateExportByID.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(templateExportByID); // http body (model) parameter
            }
            else
            {
                localVarPostBody = templateExportByID; // byte array
            }

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

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

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

        /// <summary>
        /// Export a new template 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of List&lt;Object&gt;</returns>
        public async System.Threading.Tasks.Task<RestResponse> ExportTemplateWithIRestResponseAsync(
            TemplateExportByID templateExportByID = null, CancellationToken cancellationToken = default)
        {
            var localVarPath = "/api/v2/templates/export";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (templateExportByID != null && templateExportByID.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(templateExportByID); // http body (model) parameter
            }
            else
            {
                localVarPostBody = templateExportByID; // byte array
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Export a new template 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <returns>ApiResponse of List&lt;Object&gt;</returns>
        public RestResponse ExportTemplateWithIRestResponse(TemplateExportByID templateExportByID = null)
        {
            var localVarPath = "/api/v2/templates/export";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (templateExportByID != null && templateExportByID.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(templateExportByID); // http body (model) parameter
            }
            else
            {
                localVarPostBody = templateExportByID; // byte array
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Export a new template 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <returns>ApiResponse of List&lt;Object&gt;</returns>
        public RestRequest ExportTemplateWithRestRequest(TemplateExportByID templateExportByID = null)
        {
            var localVarPath = "/api/v2/templates/export";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (templateExportByID != null && templateExportByID.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(templateExportByID); // http body (model) parameter
            }
            else
            {
                localVarPostBody = templateExportByID; // byte array
            }

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

            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>
        /// Export a new template 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of List&lt;Object&gt;</returns>
        public async System.Threading.Tasks.Task<List<object>> ExportTemplateAsync(
            TemplateExportByID templateExportByID = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await ExportTemplateAsyncWithHttpInfo(templateExportByID, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Export a new template 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (List&lt;Object&gt;)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<List<object>>> ExportTemplateAsyncWithHttpInfo(
            TemplateExportByID templateExportByID = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await ExportTemplateAsyncWithIRestResponse(templateExportByID, cancellationToken)
                .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Export a new template 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="templateExportByID">Export resources as an InfluxDB template. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (List&lt;Object&gt;)</returns>
        public async System.Threading.Tasks.Task<RestResponse> ExportTemplateAsyncWithIRestResponse(
            TemplateExportByID templateExportByID = null, CancellationToken cancellationToken = default)
        {
            var localVarPath = "/api/v2/templates/export";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (templateExportByID != null && templateExportByID.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(templateExportByID); // http body (model) parameter
            }
            else
            {
                localVarPostBody = templateExportByID; // byte array
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// List installed templates 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <returns>ListStacksResponse</returns>
        public ListStacksResponse ListStacks(string orgID, string name = null, string stackID = null)
        {
            var localVarResponse = ListStacksWithHttpInfo(orgID, name, stackID);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List installed templates 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <returns>ApiResponse of ListStacksResponse</returns>
        public ApiResponse<ListStacksResponse> ListStacksWithHttpInfo(string orgID, string name = null,
            string stackID = null)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling TemplatesService->ListStacks");
            }

            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

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

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

        /// <summary>
        /// List installed templates 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of ListStacksResponse</returns>
        public async System.Threading.Tasks.Task<RestResponse> ListStacksWithIRestResponseAsync(string orgID,
            string name = null, string stackID = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling TemplatesService->ListStacks");
            }

            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// List installed templates 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <returns>ApiResponse of ListStacksResponse</returns>
        public RestResponse ListStacksWithIRestResponse(string orgID, string name = null, string stackID = null)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling TemplatesService->ListStacks");
            }

            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// List installed templates 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <returns>ApiResponse of ListStacksResponse</returns>
        public RestRequest ListStacksWithRestRequest(string orgID, string name = null, string stackID = null)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling TemplatesService->ListStacks");
            }

            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

            if (stackID != null)
            {
                localVarQueryParams.AddRange(
                    Configuration.ApiClient.ParameterToKeyValuePairs("", "stackID", stackID)); // query 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 installed templates 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ListStacksResponse</returns>
        public async System.Threading.Tasks.Task<ListStacksResponse> ListStacksAsync(string orgID, string name = null,
            string stackID = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await ListStacksAsyncWithHttpInfo(orgID, name, stackID, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// List installed templates 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (ListStacksResponse)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<ListStacksResponse>> ListStacksAsyncWithHttpInfo(
            string orgID, string name = null, string stackID = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse = await ListStacksAsyncWithIRestResponse(orgID, name, stackID, cancellationToken)
                .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// List installed templates 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="orgID">The organization ID of the stacks</param>
        /// <param name="name">A collection of names to filter the list by. (optional)</param>
        /// <param name="stackID">A collection of stackIDs to filter the list by. (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (ListStacksResponse)</returns>
        public async System.Threading.Tasks.Task<RestResponse> ListStacksAsyncWithIRestResponse(string orgID,
            string name = null, string stackID = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'orgID' is set
            if (orgID == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'orgID' when calling TemplatesService->ListStacks");
            }

            var localVarPath = "/api/v2/stacks";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var localVarFormParams = new Dictionary<string, string>();
            var localVarFileParams = new Dictionary<string, FileParameter>();
            object localVarPostBody = null;

            // to determine the Content-Type header
            var localVarHttpContentTypes = new string[]
            {
            };
            var localVarHttpContentType = Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes);

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

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>Stack</returns>
        public Stack ReadStack(string stackId)
        {
            var localVarResponse = ReadStackWithHttpInfo(stackId);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>ApiResponse of Stack</returns>
        public ApiResponse<Stack> ReadStackWithHttpInfo(string stackId)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->ReadStack");
            }

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

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

        /// <summary>
        /// Retrieve a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Stack</returns>
        public async System.Threading.Tasks.Task<RestResponse> ReadStackWithIRestResponseAsync(string stackId,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->ReadStack");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>ApiResponse of Stack</returns>
        public RestResponse ReadStackWithIRestResponse(string stackId)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->ReadStack");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// Retrieve a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>ApiResponse of Stack</returns>
        public RestRequest ReadStackWithRestRequest(string stackId)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->ReadStack");
            }

            var localVarPath = "/api/v2/stacks/{stack_id}";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (stackId != null)
            {
                localVarPathParams.Add("stack_id",
                    Configuration.ApiClient.ParameterToString(stackId)); // path 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 stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Stack</returns>
        public async System.Threading.Tasks.Task<Stack> ReadStackAsync(string stackId,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse = await ReadStackAsyncWithHttpInfo(stackId, cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Retrieve a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Stack)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Stack>> ReadStackAsyncWithHttpInfo(string stackId,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await ReadStackAsyncWithIRestResponse(stackId, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Retrieve a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Stack)</returns>
        public async System.Threading.Tasks.Task<RestResponse> ReadStackAsyncWithIRestResponse(string stackId,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->ReadStack");
            }

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

            return localVarResponse;
        }

        /// <summary>
        /// Uninstall a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>Stack</returns>
        public Stack UninstallStack(string stackId)
        {
            var localVarResponse = UninstallStackWithHttpInfo(stackId);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Uninstall a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>ApiResponse of Stack</returns>
        public ApiResponse<Stack> UninstallStackWithHttpInfo(string stackId)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UninstallStack");
            }

            var localVarPath = "/api/v2/stacks/{stack_id}/uninstall";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (stackId != null)
            {
                localVarPathParams.Add("stack_id",
                    Configuration.ApiClient.ParameterToString(stackId)); // path 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.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Uninstall a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Stack</returns>
        public async System.Threading.Tasks.Task<RestResponse> UninstallStackWithIRestResponseAsync(string stackId,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UninstallStack");
            }

            var localVarPath = "/api/v2/stacks/{stack_id}/uninstall";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (stackId != null)
            {
                localVarPathParams.Add("stack_id",
                    Configuration.ApiClient.ParameterToString(stackId)); // path 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.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Uninstall a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>ApiResponse of Stack</returns>
        public RestResponse UninstallStackWithIRestResponse(string stackId)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UninstallStack");
            }

            var localVarPath = "/api/v2/stacks/{stack_id}/uninstall";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (stackId != null)
            {
                localVarPathParams.Add("stack_id",
                    Configuration.ApiClient.ParameterToString(stackId)); // path 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.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

            return localVarResponse;
        }

        /// <summary>
        /// Uninstall a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <returns>ApiResponse of Stack</returns>
        public RestRequest UninstallStackWithRestRequest(string stackId)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UninstallStack");
            }

            var localVarPath = "/api/v2/stacks/{stack_id}/uninstall";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (stackId != null)
            {
                localVarPathParams.Add("stack_id",
                    Configuration.ApiClient.ParameterToString(stackId)); // path 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.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType);
        }

        /// <summary>
        /// Uninstall a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Stack</returns>
        public async System.Threading.Tasks.Task<Stack> UninstallStackAsync(string stackId,
            CancellationToken cancellationToken = default)
        {
            var localVarResponse =
                await UninstallStackAsyncWithHttpInfo(stackId, cancellationToken).ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Uninstall a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Stack)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Stack>> UninstallStackAsyncWithHttpInfo(string stackId,
            CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await UninstallStackAsyncWithIRestResponse(stackId, cancellationToken).ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Uninstall a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Stack)</returns>
        public async System.Threading.Tasks.Task<RestResponse> UninstallStackAsyncWithIRestResponse(string stackId,
            CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UninstallStack");
            }

            var localVarPath = "/api/v2/stacks/{stack_id}/uninstall";
            var localVarPathParams = new Dictionary<string, string>();
            var localVarQueryParams = new List<KeyValuePair<string, string>>();
            var localVarHeaderParams = new Dictionary<string, string>(Configuration.DefaultHeader);
            var 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 (stackId != null)
            {
                localVarPathParams.Add("stack_id",
                    Configuration.ApiClient.ParameterToString(stackId)); // path 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.Post, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams,
                localVarFileParams,
                localVarPathParams, localVarHttpContentType, cancellationToken).ConfigureAwait(false);

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <returns>Stack</returns>
        public Stack UpdateStack(string stackId, PatchStackRequest patchStackRequest = null)
        {
            var localVarResponse = UpdateStackWithHttpInfo(stackId, patchStackRequest);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <returns>ApiResponse of Stack</returns>
        public ApiResponse<Stack> UpdateStackWithHttpInfo(string stackId, PatchStackRequest patchStackRequest = null)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UpdateStack");
            }

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

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

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

        /// <summary>
        /// Update a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>ApiResponse of Stack</returns>
        public async System.Threading.Tasks.Task<RestResponse> UpdateStackWithIRestResponseAsync(string stackId,
            PatchStackRequest patchStackRequest = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UpdateStack");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <returns>ApiResponse of Stack</returns>
        public RestResponse UpdateStackWithIRestResponse(string stackId, PatchStackRequest patchStackRequest = null)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UpdateStack");
            }

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

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

            return localVarResponse;
        }

        /// <summary>
        /// Update a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <returns>ApiResponse of Stack</returns>
        public RestRequest UpdateStackWithRestRequest(string stackId, PatchStackRequest patchStackRequest = null)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UpdateStack");
            }

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

            if (patchStackRequest != null && patchStackRequest.GetType() != typeof(byte[]))
            {
                localVarPostBody = Configuration.ApiClient.Serialize(patchStackRequest); // http body (model) parameter
            }
            else
            {
                localVarPostBody = patchStackRequest; // 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 stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of Stack</returns>
        public async System.Threading.Tasks.Task<Stack> UpdateStackAsync(string stackId,
            PatchStackRequest patchStackRequest = null, CancellationToken cancellationToken = default)
        {
            var localVarResponse = await UpdateStackAsyncWithHttpInfo(stackId, patchStackRequest, cancellationToken)
                .ConfigureAwait(false);
            return localVarResponse.Data;
        }

        /// <summary>
        /// Update a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of ApiResponse (Stack)</returns>
        public async System.Threading.Tasks.Task<ApiResponse<Stack>> UpdateStackAsyncWithHttpInfo(string stackId,
            PatchStackRequest patchStackRequest = null, CancellationToken cancellationToken = default)
        {
            // make the HTTP request
            var localVarResponse =
                await UpdateStackAsyncWithIRestResponse(stackId, patchStackRequest, cancellationToken)
                    .ConfigureAwait(false);

            var localVarStatusCode = (int)localVarResponse.StatusCode;

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

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

        /// <summary>
        /// Update a stack 
        /// </summary>
        /// <exception cref="InfluxDB.Client.Api.Client.ApiException">Thrown when fails to make API call</exception>
        /// <param name="stackId">The identifier of the stack.</param>
        /// <param name="patchStackRequest"> (optional)</param>
        /// <param name="cancellationToken">Cancellation token</param>
        /// <returns>Task of RestResponse (Stack)</returns>
        public async System.Threading.Tasks.Task<RestResponse> UpdateStackAsyncWithIRestResponse(string stackId,
            PatchStackRequest patchStackRequest = null, CancellationToken cancellationToken = default)
        {
            // verify the required parameter 'stackId' is set
            if (stackId == null)
            {
                throw new ApiException(400,
                    "Missing required parameter 'stackId' when calling TemplatesService->UpdateStack");
            }

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

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

            return localVarResponse;
        }
    }
}