VersClient.cs

// Generated by Sterling SDK Generator
// Orchestrator Control Plane API v0.1.0

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;

namespace VersSdk
{
    /// <summary>Per-request options that override client defaults.</summary>
    public class RequestOptions
    {
        /// <summary>Additional headers to send with the request.</summary>
        public Dictionary<string, string?>? Headers { get; set; }

        /// <summary>Request timeout. Overrides the client-level timeout.</summary>
        public TimeSpan? Timeout { get; set; }
    }

    /// <summary>Client for Orchestrator Control Plane API</summary>
    public class VersSdkClient : IDisposable
    {
        private static readonly HashSet<int> RetryableStatusCodes = new() { 408, 409, 429 };
        private static readonly JsonSerializerOptions JsonOptions = new()
        {
            PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
            DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull,
        };

        private readonly HttpClient _httpClient;
        private readonly string _baseUrl;
        private readonly string? _apiKey;
        private readonly int _maxRetries;
        private readonly TimeSpan _timeout;
        private readonly ILogger _logger;
        private readonly bool _ownsHttpClient;

        /// <summary>Create a new VersSdkClient.</summary>
        /// <param name="baseUrl">Base URL of the API. Defaults to VERS_BASE_URL env var or https://api.vers.sh.</param>
        /// <param name="apiKey">Bearer token for authentication. Defaults to VERS_API_KEY env var.</param>
        /// <param name="maxRetries">Maximum number of retries on transient failures.</param>
        /// <param name="timeout">Request timeout.</param>
        /// <param name="httpClient">Optional pre-configured HttpClient instance.</param>
        /// <param name="logger">Optional logger instance.</param>
        public VersSdkClient(
            string? baseUrl = null,
            string? apiKey = null,
            int maxRetries = 2,
            TimeSpan? timeout = null,
            HttpClient? httpClient = null,
            ILogger? logger = null)
        {
            _baseUrl = (baseUrl ?? Environment.GetEnvironmentVariable("VERS_BASE_URL") ?? "https://api.vers.sh").TrimEnd('/');
            _apiKey = apiKey ?? Environment.GetEnvironmentVariable("VERS_API_KEY");
            _maxRetries = maxRetries;
            _timeout = timeout ?? TimeSpan.FromSeconds(30);
            _logger = logger ?? NullLogger.Instance;

            if (httpClient != null)
            {
                _httpClient = httpClient;
                _ownsHttpClient = false;
            }
            else
            {
                _httpClient = new HttpClient();
                _ownsHttpClient = true;
            }

            var osDesc = RuntimeInformation.OSDescription;
            var arch = RuntimeInformation.OSArchitecture.ToString().ToLowerInvariant();
            _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(
                $"vers-sdk/0.1.8 csharp/{Environment.Version} {osDesc}/{arch}");

            if (!string.IsNullOrEmpty(_apiKey))
            {
                _httpClient.DefaultRequestHeaders.Authorization =
                    new AuthenticationHeaderValue("Bearer", _apiKey);
            }
        }

        private static bool IsRetryableStatus(int statusCode)
        {
            return statusCode >= 500 || RetryableStatusCodes.Contains(statusCode);
        }

        /// <summary>Convert a query parameter value to its string representation, with correct boolean casing.</summary>
        private static string ToQueryString(object? value)
        {
            if (value is bool b) return b ? "true" : "false";
            return value?.ToString() ?? "";
        }

        private static double RetryDelay(int attempt)
        {
            var baseDelay = 0.5 * Math.Pow(2, attempt);
            var jitter = Random.Shared.NextDouble() * baseDelay * 0.25;
            return baseDelay + jitter;
        }

        private static double? ParseRetryAfter(HttpResponseMessage response)
        {
            if (response.Headers.TryGetValues("Retry-After", out var values))
            {
                var headerValue = values.FirstOrDefault();
                if (headerValue == null) return null;

                if (double.TryParse(headerValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var seconds))
                {
                    return Math.Min(Math.Max(seconds, 0.0), 60.0);
                }

                if (DateTimeOffset.TryParse(headerValue, CultureInfo.InvariantCulture, DateTimeStyles.None, out var date))
                {
                    var delay = (date - DateTimeOffset.UtcNow).TotalSeconds;
                    return Math.Min(Math.Max(delay, 0.0), 60.0);
                }
            }
            return null;
        }

        private void CheckResponse(HttpResponseMessage response, string? body)
        {
            if (response.IsSuccessStatusCode) return;

            var statusCode = (int)response.StatusCode;
            object? parsedBody = null;
            string? message = null;

            if (!string.IsNullOrEmpty(body))
            {
                var ct = response.Content.Headers.ContentType?.MediaType ?? "";
                if (ct.Contains("application/json"))
                {
                    try
                    {
                        parsedBody = JsonSerializer.Deserialize<Dictionary<string, object>>(body!);
                    }
                    catch
                    {
                        message = body;
                    }
                }
                else
                {
                    message = body;
                }
            }

            var headers = response.Headers
                .Concat(response.Content.Headers)
                .ToDictionary(h => h.Key, h => string.Join(", ", h.Value));

            throw ApiException.Generate(statusCode, parsedBody, message, headers);
        }

        private async Task<HttpResponseMessage> RequestAsync(
            HttpMethod method,
            string path,
            object? body = null,
            Dictionary<string, string?>? queryParams = null,
            RequestOptions? options = null,
            CancellationToken cancellationToken = default)
        {
            _logger.LogDebug("request: {Method} {Path}", method, path);

            var effectiveTimeout = options?.Timeout ?? _timeout;
            Exception? lastException = null;
            var retryAfterUsed = false;

            for (int attempt = 0; attempt <= _maxRetries; attempt++)
            {
                if (attempt > 0 && !retryAfterUsed)
                {
                    _logger.LogInformation("retry attempt {Attempt}/{MaxRetries} for {Method} {Path}",
                        attempt, _maxRetries, method, path);
                    await Task.Delay(TimeSpan.FromSeconds(RetryDelay(attempt - 1)), cancellationToken);
                }
                retryAfterUsed = false;

                try
                {
                    var url = _baseUrl + path;
                    if (queryParams != null && queryParams.Count > 0)
                    {
                        var qp = string.Join("&", queryParams
                            .Where(kv => kv.Value != null)
                            .Select(kv => $"{Uri.EscapeDataString(kv.Key)}={Uri.EscapeDataString(kv.Value!)}"));
                        if (qp.Length > 0)
                            url += "?" + qp;
                    }

                    using var request = new HttpRequestMessage(method, url);

                    // Idempotency key for mutating methods
                    if (method == HttpMethod.Post || method == HttpMethod.Put ||
                        method == HttpMethod.Patch || method == HttpMethod.Delete)
                    {
                        request.Headers.Add("X-Idempotency-Key", Guid.NewGuid().ToString());
                    }

                    // Apply per-request headers
                    if (options?.Headers != null)
                    {
                        foreach (var (key, value) in options.Headers)
                        {
                            if (value == null)
                            {
                                request.Headers.Remove(key);
                            }
                            else
                            {
                                request.Headers.TryAddWithoutValidation(key, value);
                            }
                        }
                    }

                    if (body != null)
                    {
                        var json = JsonSerializer.Serialize(body, JsonOptions);
                        request.Content = new StringContent(json, Encoding.UTF8, "application/json");
                    }

                    using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                    cts.CancelAfter(effectiveTimeout);

                    var response = await _httpClient.SendAsync(request, cts.Token);
                    var responseBody = await response.Content.ReadAsStringAsync(cts.Token);

                    _logger.LogDebug("response: {StatusCode} for {Method} {Path}",
                        (int)response.StatusCode, method, path);

                    var statusCode = (int)response.StatusCode;
                    if (IsRetryableStatus(statusCode) && attempt < _maxRetries)
                    {
                        var retryAfterDelay = ParseRetryAfter(response);
                        if (retryAfterDelay.HasValue)
                        {
                            retryAfterUsed = true;
                            _logger.LogInformation(
                                "retry attempt {Attempt}/{MaxRetries} for {Method} {Path} (retry-after: {Delay:F1}s)",
                                attempt + 1, _maxRetries, method, path, retryAfterDelay.Value);
                            await Task.Delay(TimeSpan.FromSeconds(retryAfterDelay.Value), cancellationToken);
                        }
                        lastException = new Exception($"HTTP {statusCode}");
                        continue;
                    }

                    CheckResponse(response, responseBody);

                    // Return a new response with the body re-attached since we consumed it
                    var result = new HttpResponseMessage(response.StatusCode);
                    result.Content = new StringContent(responseBody, Encoding.UTF8, "application/json");
                    foreach (var header in response.Headers)
                        result.Headers.TryAddWithoutValidation(header.Key, header.Value);
                    return result;
                }
                catch (ApiException)
                {
                    throw;
                }
                catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
                {
                    _logger.LogError("timeout: {Method} {Path}", method, path);
                    if (attempt == _maxRetries)
                        throw new ApiTimeoutException();
                    lastException = new ApiTimeoutException();
                }
                catch (HttpRequestException ex)
                {
                    _logger.LogError("connection error: {Method} {Path} - {Error}", method, path, ex.Message);
                    if (attempt == _maxRetries)
                        throw new ApiConnectionException(cause: ex);
                    lastException = ex;
                }
            }

            throw lastException ?? new VersException("Request failed after retries.");
        }

        // ── API Operations ──────────────────────────────────────────────────

        /// <summary></summary>
        public async Task<JsonElement> VmStatusAsync(string vm_id, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/status";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ResizeVmDiskAsync(string vm_id, object? body = null, ResizeVmDiskParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/disk";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.SkipWaitBoot != null)
                    qp["skip_wait_boot"] = ToQueryString(queryParams.SkipWaitBoot);
            }
            var response = await RequestAsync(
                new HttpMethod("PATCH"),
                path,
                body: body,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ExecVmStreamAttachAsync(string vm_id, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/exec/stream/attach";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListVmsAsync(RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/vms";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> CreateNewRootVmAsync(object? body = null, CreateNewRootVmParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/vm/new_root";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.WaitBoot != null)
                    qp["wait_boot"] = ToQueryString(queryParams.WaitBoot);
            }
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> VmLogsAsync(string vm_id, VmLogsParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/logs";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.Offset != null)
                    qp["offset"] = ToQueryString(queryParams.Offset);
                if (queryParams.MaxEntries != null)
                    qp["max_entries"] = ToQueryString(queryParams.MaxEntries);
                if (queryParams.Stream != null)
                    qp["stream"] = ToQueryString(queryParams.Stream);
            }
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> BranchByRefAsync(string repo_name, string tag_name, object? body = null, BranchByRefParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/branch/by_ref/{repo_name}/{tag_name}";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.Count != null)
                    qp["count"] = ToQueryString(queryParams.Count);
            }
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> LabelVmAsync(string vm_id, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/label";
            var response = await RequestAsync(
                new HttpMethod("PATCH"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListPublicCommitsAsync(RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/commits/public";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> GetImageStatusAsync(string image_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/images/{image_name}/status";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListPublicRepoTagsAsync(string org_name, string repo_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/public/repositories/{org_name}/{repo_name}/tags";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> VersionHandlerAsync(RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/system/version";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> BranchByTagAsync(string tag_name, object? body = null, BranchByTagParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/branch/by_tag/{tag_name}";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.Count != null)
                    qp["count"] = ToQueryString(queryParams.Count);
            }
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> GetRepoTagAsync(string repo_name, string tag_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/repositories/{repo_name}/tags/{tag_name}";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> DeleteRepoTagAsync(string repo_name, string tag_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/repositories/{repo_name}/tags/{tag_name}";
            var response = await RequestAsync(
                new HttpMethod("DELETE"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> UpdateRepoTagAsync(string repo_name, string tag_name, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/repositories/{repo_name}/tags/{tag_name}";
            var response = await RequestAsync(
                new HttpMethod("PATCH"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> BranchVmAsync(string vm_or_commit_id, object? body = null, BranchVmParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_or_commit_id}/branch";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.KeepPaused != null)
                    qp["keep_paused"] = ToQueryString(queryParams.KeepPaused);
                if (queryParams.SkipWaitBoot != null)
                    qp["skip_wait_boot"] = ToQueryString(queryParams.SkipWaitBoot);
                if (queryParams.Count != null)
                    qp["count"] = ToQueryString(queryParams.Count);
            }
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> GetRepositoryAsync(string repo_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/repositories/{repo_name}";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> DeleteRepositoryAsync(string repo_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/repositories/{repo_name}";
            var response = await RequestAsync(
                new HttpMethod("DELETE"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListParentCommitsAsync(string commit_id, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/commits/{commit_id}/parents";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ValidateKeyAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/keys/validate";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ForkRepositoryAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/repositories/fork";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListRepositoriesAsync(RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/repositories";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> CreateRepositoryAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/repositories";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> UpdateVmStateAsync(string vm_id, object? body = null, UpdateVmStateParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/state";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.SkipWaitBoot != null)
                    qp["skip_wait_boot"] = ToQueryString(queryParams.SkipWaitBoot);
            }
            var response = await RequestAsync(
                new HttpMethod("PATCH"),
                path,
                body: body,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> CreateImageAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/images/create";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> RestoreFromCommitAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/vm/from_commit";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> GetDomainAsync(string domain_id, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/domains/{domain_id}";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> DeleteDomainAsync(string domain_id, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/domains/{domain_id}";
            var response = await RequestAsync(
                new HttpMethod("DELETE"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListTagsAsync(RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/commit_tags";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> CreateTagAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/commit_tags";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListPublicRepositoriesAsync(RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/public/repositories";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> GetPublicRepoTagAsync(string org_name, string repo_name, string tag_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/public/repositories/{org_name}/{repo_name}/tags/{tag_name}";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> GetVmMetadataAsync(string vm_id, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/metadata";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListEnvVarsAsync(RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/env_vars";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> SetEnvVarsAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/env_vars";
            var response = await RequestAsync(
                new HttpMethod("PUT"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> DeleteVmAsync(string vm_id, DeleteVmParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.SkipWaitBoot != null)
                    qp["skip_wait_boot"] = ToQueryString(queryParams.SkipWaitBoot);
            }
            var response = await RequestAsync(
                new HttpMethod("DELETE"),
                path,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListCommitsAsync(RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/commits";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> GetTagAsync(string tag_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/commit_tags/{tag_name}";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> DeleteTagAsync(string tag_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/commit_tags/{tag_name}";
            var response = await RequestAsync(
                new HttpMethod("DELETE"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> UpdateTagAsync(string tag_name, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/commit_tags/{tag_name}";
            var response = await RequestAsync(
                new HttpMethod("PATCH"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> BranchByVmAsync(string vm_id, object? body = null, BranchByVmParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/branch/by_vm/{vm_id}";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.KeepPaused != null)
                    qp["keep_paused"] = ToQueryString(queryParams.KeepPaused);
                if (queryParams.SkipWaitBoot != null)
                    qp["skip_wait_boot"] = ToQueryString(queryParams.SkipWaitBoot);
                if (queryParams.Count != null)
                    qp["count"] = ToQueryString(queryParams.Count);
            }
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> DeleteEnvVarAsync(string key, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/env_vars/{key}";
            var response = await RequestAsync(
                new HttpMethod("DELETE"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> DeleteImageAsync(string base_image_id, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/images/images/{base_image_id}";
            var response = await RequestAsync(
                new HttpMethod("DELETE"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> CommitVmAsync(string vm_id, object? body = null, CommitVmParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/commit";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.KeepPaused != null)
                    qp["keep_paused"] = ToQueryString(queryParams.KeepPaused);
                if (queryParams.SkipWaitBoot != null)
                    qp["skip_wait_boot"] = ToQueryString(queryParams.SkipWaitBoot);
            }
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> DeleteCommitAsync(string commit_id, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/commits/{commit_id}";
            var response = await RequestAsync(
                new HttpMethod("DELETE"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> UpdateCommitAsync(string commit_id, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/commits/{commit_id}";
            var response = await RequestAsync(
                new HttpMethod("PATCH"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListRepoTagsAsync(string repo_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/repositories/{repo_name}/tags";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> CreateRepoTagAsync(string repo_name, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/repositories/{repo_name}/tags";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary>Deploy a GitHub repository to a new Vers project.</summary>
        public async Task<JsonElement> DeployHandlerAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/deploy";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ExecVmAsync(string vm_id, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/exec";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> SetRepositoryVisibilityAsync(string repo_name, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/repositories/{repo_name}/visibility";
            var response = await RequestAsync(
                new HttpMethod("PATCH"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ExecVmStreamAsync(string vm_id, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/exec/stream";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListDomainsAsync(ListDomainsParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/domains";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.VmId != null)
                    qp["vm_id"] = ToQueryString(queryParams.VmId);
            }
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> CreateDomainAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/domains";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> SshKeyAsync(string vm_id, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/ssh_key";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ListImagesAsync(RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/images";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> ReadFileVmAsync(string vm_id, ReadFileVmParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/files";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.Path != null)
                    qp["path"] = ToQueryString(queryParams.Path);
            }
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> WriteFileVmAsync(string vm_id, object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/{vm_id}/files";
            var response = await RequestAsync(
                new HttpMethod("PUT"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> UploadImageAsync(object? body = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = "/api/v1/images/upload";
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> GetPublicRepositoryAsync(string org_name, string repo_name, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/public/repositories/{org_name}/{repo_name}";
            var response = await RequestAsync(
                new HttpMethod("GET"),
                path,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary></summary>
        public async Task<JsonElement> BranchByCommitAsync(string commit_id, object? body = null, BranchByCommitParams? queryParams = null, RequestOptions? options = null, CancellationToken cancellationToken = default)
        {
            var path = $"/api/v1/vm/branch/by_commit/{commit_id}";
            Dictionary<string, string?>? qp = null;
            if (queryParams != null)
            {
                qp = new Dictionary<string, string?>();
                if (queryParams.Count != null)
                    qp["count"] = ToQueryString(queryParams.Count);
            }
            var response = await RequestAsync(
                new HttpMethod("POST"),
                path,
                body: body,
                queryParams: qp,
                options: options,
                cancellationToken: cancellationToken);
            var json = await response.Content.ReadAsStringAsync(cancellationToken);
            return JsonSerializer.Deserialize<JsonElement>(json);
        }

        /// <summary>Dispose the underlying HttpClient if owned by this instance.</summary>
        public void Dispose()
        {
            if (_ownsHttpClient)
            {
                _httpClient.Dispose();
            }
            GC.SuppressFinalize(this);
        }
    }
}