diff --git a/src/libs/Mubert/Generated/Mubert.AutoSDKHttpResponse.g.cs b/src/libs/Mubert/Generated/Mubert.AutoSDKHttpResponse.g.cs
new file mode 100644
index 0000000..7553c8f
--- /dev/null
+++ b/src/libs/Mubert/Generated/Mubert.AutoSDKHttpResponse.g.cs
@@ -0,0 +1,121 @@
+
+#nullable enable
+
+namespace Mubert
+{
+    /// <summary>
+    /// Represents a successful HTTP response with status code and headers.
+    /// </summary>
+    public partial class AutoSDKHttpResponse
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AutoSDKHttpResponse"/> class.
+        /// </summary>
+        public AutoSDKHttpResponse(
+            global::System.Net.HttpStatusCode statusCode,
+            global::System.Collections.Generic.Dictionary<string, global::System.Collections.Generic.IEnumerable<string>> headers)
+            : this(
+                statusCode: statusCode,
+                headers: headers,
+                requestUri: null)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AutoSDKHttpResponse"/> class.
+        /// </summary>
+        public AutoSDKHttpResponse(
+            global::System.Net.HttpStatusCode statusCode,
+            global::System.Collections.Generic.Dictionary<string, global::System.Collections.Generic.IEnumerable<string>> headers,
+            global::System.Uri? requestUri)
+        {
+            StatusCode = statusCode;
+            Headers = headers ?? throw new global::System.ArgumentNullException(nameof(headers));
+            RequestUri = requestUri;
+        }
+
+        /// <summary>
+        /// Gets the HTTP status code.
+        /// </summary>
+        public global::System.Net.HttpStatusCode StatusCode { get; }
+        /// <summary>
+        /// Gets the response headers.
+        /// </summary>
+        public global::System.Collections.Generic.Dictionary<string, global::System.Collections.Generic.IEnumerable<string>> Headers { get; }
+        /// <summary>
+        /// Gets the final request URI associated with the response.
+        /// </summary>
+        public global::System.Uri? RequestUri { get; }
+
+        internal static global::System.Collections.Generic.Dictionary<string, global::System.Collections.Generic.IEnumerable<string>> CreateHeaders(
+            global::System.Net.Http.HttpResponseMessage response)
+        {
+            response = response ?? throw new global::System.ArgumentNullException(nameof(response));
+
+            var headers = global::System.Linq.Enumerable.ToDictionary(
+                response.Headers,
+                static header => header.Key,
+                static header => (global::System.Collections.Generic.IEnumerable<string>)global::System.Linq.Enumerable.ToArray(header.Value),
+                global::System.StringComparer.OrdinalIgnoreCase);
+
+            if (response.Content?.Headers == null)
+            {
+                return headers;
+            }
+
+            foreach (var header in response.Content.Headers)
+            {
+                if (headers.TryGetValue(header.Key, out var existingValues))
+                {
+                    headers[header.Key] = global::System.Linq.Enumerable.ToArray(
+                        global::System.Linq.Enumerable.Concat(existingValues, header.Value));
+                }
+                else
+                {
+                    headers[header.Key] = global::System.Linq.Enumerable.ToArray(header.Value);
+                }
+            }
+
+            return headers;
+        }
+    }
+
+    /// <summary>
+    /// Represents a successful HTTP response with status code, headers, and body.
+    /// </summary>
+    public partial class AutoSDKHttpResponse<T> : AutoSDKHttpResponse
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AutoSDKHttpResponse{T}"/> class.
+        /// </summary>
+        public AutoSDKHttpResponse(
+            global::System.Net.HttpStatusCode statusCode,
+            global::System.Collections.Generic.Dictionary<string, global::System.Collections.Generic.IEnumerable<string>> headers,
+            T body)
+            : this(
+                statusCode: statusCode,
+                headers: headers,
+                requestUri: null,
+                body: body)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AutoSDKHttpResponse{T}"/> class.
+        /// </summary>
+        public AutoSDKHttpResponse(
+            global::System.Net.HttpStatusCode statusCode,
+            global::System.Collections.Generic.Dictionary<string, global::System.Collections.Generic.IEnumerable<string>> headers,
+            global::System.Uri? requestUri,
+            T body)
+            : base(statusCode, headers, requestUri)
+        {
+            Body = body;
+        }
+
+        /// <summary>
+        /// Gets the response body.
+        /// </summary>
+        public T Body { get; }
+    }
+}
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicMusicLibraryParams.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicMusicLibraryParams.g.cs
index 6d75455..18a300d 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicMusicLibraryParams.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicMusicLibraryParams.g.cs
@@ -56,5 +56,57 @@ public partial interface IPublicClient
             global::Mubert.TrackModeEnum? mode = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Get music library filter parameters<br/>
+        /// Retrieve available filter parameters and track counts for the music library. Use filters to refine results — multiple filters are combined with logical AND.
+        /// </summary>
+        /// <param name="bpm">
+        /// Example: 120
+        /// </param>
+        /// <param name="key">
+        /// Key-Scale for a track.<br/>
+        /// Example: C#
+        /// </param>
+        /// <param name="genres">
+        /// Example: Rock
+        /// </param>
+        /// <param name="moods">
+        /// Example: Happy
+        /// </param>
+        /// <param name="activities">
+        /// Example: Minimal 170
+        /// </param>
+        /// <param name="playlists">
+        /// Example: Chill Vibes
+        /// </param>
+        /// <param name="instruments">
+        /// Example: Guitar
+        /// </param>
+        /// <param name="themes">
+        /// Example: Corporate
+        /// </param>
+        /// <param name="duration">
+        /// Example: 180
+        /// </param>
+        /// <param name="mode">
+        /// Enumeration representing different modes of a track.<br/>
+        /// Example: loop
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>>> GetPublicMusicLibraryParamsAsResponseAsync(
+            int? bpm = default,
+            global::Mubert.TrackKeyScaleEnum? key = default,
+            string? genres = default,
+            string? moods = default,
+            string? activities = default,
+            string? playlists = default,
+            string? instruments = default,
+            string? themes = default,
+            int? duration = default,
+            global::Mubert.TrackModeEnum? mode = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicMusicLibraryTracks.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicMusicLibraryTracks.g.cs
index 69c3d2c..d58751b 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicMusicLibraryTracks.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicMusicLibraryTracks.g.cs
@@ -72,5 +72,73 @@ public partial interface IPublicClient
             global::Mubert.TrackModeEnum? mode = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// List music library tracks<br/>
+        /// Retrieve a paginated list of pre-generated music library tracks with optional filtering by genre, mood, BPM, key, and other parameters.
+        /// </summary>
+        /// <param name="offset">
+        /// Example: 0
+        /// </param>
+        /// <param name="limit">
+        /// Example: 25
+        /// </param>
+        /// <param name="order">
+        /// Example: asc
+        /// </param>
+        /// <param name="orderBy">
+        /// Example: created_at
+        /// </param>
+        /// <param name="bpm">
+        /// Example: 120
+        /// </param>
+        /// <param name="key">
+        /// Key-Scale for a track.<br/>
+        /// Example: C#
+        /// </param>
+        /// <param name="genres">
+        /// Example: Rock
+        /// </param>
+        /// <param name="moods">
+        /// Example: Happy
+        /// </param>
+        /// <param name="activities">
+        /// Example: Minimal 170
+        /// </param>
+        /// <param name="playlists">
+        /// Example: Chill Vibes
+        /// </param>
+        /// <param name="instruments">
+        /// Example: Guitar
+        /// </param>
+        /// <param name="themes">
+        /// Example: Corporate
+        /// </param>
+        /// <param name="duration">
+        /// Example: 180
+        /// </param>
+        /// <param name="mode">
+        /// Enumeration representing different modes of a track.<br/>
+        /// Example: loop
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicMusicLibraryTracksResponse>> GetPublicMusicLibraryTracksAsResponseAsync(
+            int? offset = default,
+            int? limit = default,
+            global::Mubert.GetPublicMusicLibraryTracksOrder? order = default,
+            string? orderBy = default,
+            int? bpm = default,
+            global::Mubert.TrackKeyScaleEnum? key = default,
+            string? genres = default,
+            string? moods = default,
+            string? activities = default,
+            string? playlists = default,
+            string? instruments = default,
+            string? themes = default,
+            int? duration = default,
+            global::Mubert.TrackModeEnum? mode = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPlaylists.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPlaylists.g.cs
index c323433..28ee609 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPlaylists.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPlaylists.g.cs
@@ -14,5 +14,15 @@ public partial interface IPublicClient
         global::System.Threading.Tasks.Task<global::Mubert.GetPublicPlaylistsResponse> GetPublicPlaylistsAsync(
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// List playlists<br/>
+        /// Retrieve all available music channels, groups, and categories. Each entry includes a playlist_index identifier, category, group, channel name, and available parameters (BPM range, keys).
+        /// </summary>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPlaylistsResponse>> GetPublicPlaylistsAsResponseAsync(
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPrices.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPrices.g.cs
index e9b3be0..ffaa9cd 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPrices.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPrices.g.cs
@@ -17,5 +17,18 @@ public partial interface IPublicClient
             global::Mubert.LanguageEnum? lang = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Retrieve a list of available prices with their options, limits, and Stripe prices
+        /// </summary>
+        /// <param name="lang">
+        /// Languages
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPricesResponse>> GetPublicPricesAsResponseAsync(
+            global::Mubert.LanguageEnum? lang = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPricesByPrice.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPricesByPrice.g.cs
index d2a111b..c657f58 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPricesByPrice.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicPricesByPrice.g.cs
@@ -21,5 +21,22 @@ public partial interface IPublicClient
             global::Mubert.LanguageEnum? lang = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Retrieve a single price by ID with its options, limits, and Stripe prices
+        /// </summary>
+        /// <param name="price">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="lang">
+        /// Languages
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPricesByPriceResponse>> GetPublicPricesByPriceAsResponseAsync(
+            global::System.Guid price,
+            global::Mubert.LanguageEnum? lang = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicStreamingGetLink.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicStreamingGetLink.g.cs
index a2890ee..f858cb7 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicStreamingGetLink.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicStreamingGetLink.g.cs
@@ -32,5 +32,33 @@ public partial interface IPublicClient
             global::Mubert.StreamingTypeEnum? type = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Get streaming link<br/>
+        /// Generate a streaming URL for continuous music playback. The returned link can be used in any audio player that supports HTTP streaming or WebRTC.
+        /// </summary>
+        /// <param name="playlistIndex">
+        /// Example: 1.0.0
+        /// </param>
+        /// <param name="bitrate">
+        /// Enumeration representing different track bitrates.<br/>
+        /// Example: 320
+        /// </param>
+        /// <param name="intensity">
+        /// Enumeration representing different intensity levels of a track.<br/>
+        /// Example: medium
+        /// </param>
+        /// <param name="type">
+        /// Streaming Type Enum
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicStreamingGetLinkResponse>> GetPublicStreamingGetLinkAsResponseAsync(
+            string playlistIndex,
+            int? bitrate = default,
+            global::Mubert.TrackIntensityEnum? intensity = default,
+            global::Mubert.StreamingTypeEnum? type = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicSubscriptionsBuy.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicSubscriptionsBuy.g.cs
index 0a4dcb9..5dc3cbd 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicSubscriptionsBuy.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicSubscriptionsBuy.g.cs
@@ -19,6 +19,18 @@ public partial interface IPublicClient
         /// <summary>
         /// Buy a subscription via GET (redirect flow). Creates a Stripe Checkout session and redirects to checkout URL.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicSubscriptionsBuyResponse>> GetPublicSubscriptionsBuyAsResponseAsync(
+
+            global::Mubert.GetPublicSubscriptionsBuyRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Buy a subscription via GET (redirect flow). Creates a Stripe Checkout session and redirects to checkout URL.
+        /// </summary>
         /// <param name="companyName">
         /// Example: Acme Inc
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicSubscriptionsCancel.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicSubscriptionsCancel.g.cs
index 732c4c5..dbaea14 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicSubscriptionsCancel.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicSubscriptionsCancel.g.cs
@@ -21,6 +21,19 @@ public partial interface IPublicClient
         /// Cancel Subscription (GET)<br/>
         /// Cancel a subscription via GET. Cancels at the end of the current billing period.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> GetPublicSubscriptionsCancelAsResponseAsync(
+
+            global::Mubert.GetPublicSubscriptionsCancelRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Cancel Subscription (GET)<br/>
+        /// Cancel a subscription via GET. Cancels at the end of the current billing period.
+        /// </summary>
         /// <param name="companyId">
         /// Example: 550e8400-e29b-41d4-a716-446655440000
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracks.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracks.g.cs
index 6a7e628..1e37923 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracks.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracks.g.cs
@@ -30,5 +30,31 @@ public partial interface IPublicClient
             string? orderBy = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// List tracks<br/>
+        /// Retrieve a paginated list of tracks generated by the customer.
+        /// </summary>
+        /// <param name="offset">
+        /// Example: 0
+        /// </param>
+        /// <param name="limit">
+        /// Example: 25
+        /// </param>
+        /// <param name="order">
+        /// Example: asc
+        /// </param>
+        /// <param name="orderBy">
+        /// Example: created_at
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksResponse>> GetPublicTracksAsResponseAsync(
+            int? offset = default,
+            int? limit = default,
+            global::Mubert.GetPublicTracksOrder? order = default,
+            string? orderBy = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracksByTrack.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracksByTrack.g.cs
index 334a1f0..f48e66b 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracksByTrack.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracksByTrack.g.cs
@@ -18,5 +18,19 @@ public partial interface IPublicClient
             global::System.Guid track,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Get track by ID<br/>
+        /// Retrieve specific track details including generation status, download URLs, and expiration times.
+        /// </summary>
+        /// <param name="track">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksByTrackResponse>> GetPublicTracksByTrackAsResponseAsync(
+            global::System.Guid track,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracksSessionBySessionId.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracksSessionBySessionId.g.cs
index 5946fe5..2a1458b 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracksSessionBySessionId.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.GetPublicTracksSessionBySessionId.g.cs
@@ -20,5 +20,21 @@ public partial interface IPublicClient
             string sessionId,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Get track by session ID<br/>
+        /// Retrieve specific track details by session ID including generation status, download URLs, and expiration times.
+        /// </summary>
+        /// <param name="track">
+        /// Example: 4b19470aec7446d0a8e3c05d06b23ce2
+        /// </param>
+        /// <param name="sessionId"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksSessionBySessionIdResponse>> GetPublicTracksSessionBySessionIdAsResponseAsync(
+            string track,
+            string sessionId,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingRestart.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingRestart.g.cs
index b42f746..2417c7d 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingRestart.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingRestart.g.cs
@@ -21,6 +21,19 @@ public partial interface IPublicClient
         /// Restart stream<br/>
         /// Restart the stream so that a different track is played using the same streaming URL.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicStreamingRestartAsResponseAsync(
+
+            object request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Restart stream<br/>
+        /// Restart the stream so that a different track is played using the same streaming URL.
+        /// </summary>
         /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
         /// <param name="cancellationToken">The token to cancel the operation with</param>
         /// <exception cref="global::System.InvalidOperationException"></exception>
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingSetIntensity.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingSetIntensity.g.cs
index 8b218d5..bccd623 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingSetIntensity.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingSetIntensity.g.cs
@@ -21,6 +21,19 @@ public partial interface IPublicClient
         /// Set stream intensity<br/>
         /// Dynamically adjust the arrangement complexity during streaming. Changes occur seamlessly without stream interruption.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicStreamingSetIntensityAsResponseAsync(
+
+            global::Mubert.PostPublicStreamingSetIntensityRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Set stream intensity<br/>
+        /// Dynamically adjust the arrangement complexity during streaming. Changes occur seamlessly without stream interruption.
+        /// </summary>
         /// <param name="intensity">
         /// Enumeration representing different intensity levels of a track.<br/>
         /// Example: medium
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingSetLoopState.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingSetLoopState.g.cs
index 5cc6426..60bd694 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingSetLoopState.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStreamingSetLoopState.g.cs
@@ -21,6 +21,19 @@ public partial interface IPublicClient
         /// Set stream loop state<br/>
         /// Enable or disable loop mode for the current stream segment. When enabled, the later part of the music composition will loop continuously.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicStreamingSetLoopStateAsResponseAsync(
+
+            global::Mubert.PostPublicStreamingSetLoopStateRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Set stream loop state<br/>
+        /// Enable or disable loop mode for the current stream segment. When enabled, the later part of the music composition will loop continuously.
+        /// </summary>
         /// <param name="loop">
         /// Streaming Loop State
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStripeWebhook.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStripeWebhook.g.cs
index aff48e0..fae929d 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStripeWebhook.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicStripeWebhook.g.cs
@@ -13,5 +13,14 @@ public partial interface IPublicClient
         global::System.Threading.Tasks.Task PostPublicStripeWebhookAsync(
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Stripe webhook endpoint for processing payment events
+        /// </summary>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicStripeWebhookAsResponseAsync(
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicSubscriptionsBuy.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicSubscriptionsBuy.g.cs
index 889e435..9802293 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicSubscriptionsBuy.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicSubscriptionsBuy.g.cs
@@ -19,6 +19,18 @@ public partial interface IPublicClient
         /// <summary>
         /// Buy a subscription. Creates a Stripe Checkout session and returns the checkout URL.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicSubscriptionsBuyResponse>> PostPublicSubscriptionsBuyAsResponseAsync(
+
+            global::Mubert.PostPublicSubscriptionsBuyRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Buy a subscription. Creates a Stripe Checkout session and returns the checkout URL.
+        /// </summary>
         /// <param name="companyName">
         /// Example: Acme Inc
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicSubscriptionsCancel.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicSubscriptionsCancel.g.cs
index 8960e28..0d8897a 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicSubscriptionsCancel.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicSubscriptionsCancel.g.cs
@@ -21,6 +21,19 @@ public partial interface IPublicClient
         /// Cancel Subscription<br/>
         /// Cancel a subscription by company ID and license token. Cancels at the end of the current billing period.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicSubscriptionsCancelAsResponseAsync(
+
+            global::Mubert.PostPublicSubscriptionsCancelRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Cancel Subscription<br/>
+        /// Cancel a subscription by company ID and license token. Cancels at the end of the current billing period.
+        /// </summary>
         /// <param name="companyId">
         /// Example: 550e8400-e29b-41d4-a716-446655440000
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracks.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracks.g.cs
index 7796ead..89ac3dc 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracks.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracks.g.cs
@@ -21,6 +21,19 @@ public partial interface IPublicClient
         /// Create track<br/>
         /// Create a custom music track from channel/category parameters, text prompt, or image. Supports multiple generation modes: track, loop, jingle, and mix.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksResponse>> PostPublicTracksAsResponseAsync(
+
+            global::Mubert.PostPublicTracksRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Create track<br/>
+        /// Create a custom music track from channel/category parameters, text prompt, or image. Supports multiple generation modes: track, loop, jingle, and mix.
+        /// </summary>
         /// <param name="playlistIndex">
         /// Index of the playlist. Required if `prompt`, and `image` are not provided. If provided, `bpm` and `key` can be optionally specified.<br/>
         /// Example: 1.0.0
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksByTrackEdit.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksByTrackEdit.g.cs
index 8db787c..f4c9ad7 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksByTrackEdit.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksByTrackEdit.g.cs
@@ -28,6 +28,23 @@ public partial interface IPublicClient
         /// <param name="track">
         /// Example: 123e4567-e89b-12d3-a456-426614174000
         /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksByTrackEditResponse>> PostPublicTracksByTrackEditAsResponseAsync(
+            global::System.Guid track,
+
+            global::Mubert.PostPublicTracksByTrackEditRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Edit track<br/>
+        /// Modify track parameters or manipulate instrument/stem composition. Allows changing duration, bitrate, format, intensity, as well as replacing or removing specific instruments and stems.
+        /// </summary>
+        /// <param name="track">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
         /// <param name="bitrate">
         /// Enumeration representing different track bitrates.<br/>
         /// Example: 320
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksByTrackSimilar.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksByTrackSimilar.g.cs
index 587a4d7..412b2cf 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksByTrackSimilar.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksByTrackSimilar.g.cs
@@ -28,6 +28,23 @@ public partial interface IPublicClient
         /// <param name="track">
         /// Example: 123e4567-e89b-12d3-a456-426614174000
         /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksByTrackSimilarResponse>> PostPublicTracksByTrackSimilarAsResponseAsync(
+            global::System.Guid track,
+
+            global::Mubert.PostPublicTracksByTrackSimilarRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Generate similar track<br/>
+        /// Generate a new track similar to an existing one. Uses the original track parameters as a base and allows overriding duration, bitrate, format, intensity, and mode.
+        /// </summary>
+        /// <param name="track">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
         /// <param name="bitrate">
         /// Enumeration representing different track bitrates.<br/>
         /// Example: 320
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksRecord.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksRecord.g.cs
index dc31201..7cf6925 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksRecord.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksRecord.g.cs
@@ -21,6 +21,19 @@ public partial interface IPublicClient
         /// Record track<br/>
         /// Record a new track by sending a request directly to the track-recorder service, bypassing the track-store cache.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksRecordResponse>> PostPublicTracksRecordAsResponseAsync(
+
+            global::Mubert.PostPublicTracksRecordRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Record track<br/>
+        /// Record a new track by sending a request directly to the track-recorder service, bypassing the track-store cache.
+        /// </summary>
         /// <param name="playlistIndex">
         /// Index of the playlist. Required if `prompt`, and `image` are not provided. If provided, `bpm` and `key` can be optionally specified.<br/>
         /// Example: 1.0.0
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksStored.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksStored.g.cs
index 7a70140..a14e1f0 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksStored.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicClient.PostPublicTracksStored.g.cs
@@ -21,6 +21,19 @@ public partial interface IPublicClient
         /// Get stored track<br/>
         /// Retrieve a pre-generated track from the track-store. Returns a cached track matching the requested parameters if available.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksStoredResponse>> PostPublicTracksStoredAsResponseAsync(
+
+            global::Mubert.PostPublicTracksStoredRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Get stored track<br/>
+        /// Retrieve a pre-generated track from the track-store. Returns a cached track matching the requested parameters if available.
+        /// </summary>
         /// <param name="playlistIndex">
         /// The index of the playlist, required if stream_id is not provided.<br/>
         /// Example: 1.0.1
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.DeleteServiceCustomersByCustomer.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.DeleteServiceCustomersByCustomer.g.cs
index 7df0b61..94a0676 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.DeleteServiceCustomersByCustomer.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.DeleteServiceCustomersByCustomer.g.cs
@@ -28,6 +28,23 @@ public partial interface IPublicServiceClient
         /// <param name="customer">
         /// Example: 123e4567-e89b-12d3-a456-426614174000
         /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> DeleteServiceCustomersByCustomerAsResponseAsync(
+            global::System.Guid customer,
+
+            object request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Delete customer<br/>
+        /// Remove a customer account by their unique identifier. This action is irreversible.
+        /// </summary>
+        /// <param name="customer">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
         /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
         /// <param name="cancellationToken">The token to cancel the operation with</param>
         /// <exception cref="global::System.InvalidOperationException"></exception>
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomers.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomers.g.cs
index ea3817f..389211d 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomers.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomers.g.cs
@@ -22,5 +22,23 @@ public partial interface IPublicServiceClient
             int? limit = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Retrieve a list of customers<br/>
+        /// Fetches a list of customers with optional pagination
+        /// </summary>
+        /// <param name="offset">
+        /// Example: 0
+        /// </param>
+        /// <param name="limit">
+        /// Example: 25
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceCustomersResponse>> GetServiceCustomersAsResponseAsync(
+            int? offset = default,
+            int? limit = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomersByCustomer.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomersByCustomer.g.cs
index c8ce3ad..25b9a95 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomersByCustomer.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomersByCustomer.g.cs
@@ -18,5 +18,19 @@ public partial interface IPublicServiceClient
             global::System.Guid customer,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Retrieve customer details by ID<br/>
+        /// Fetches the details of a specific customer using their unique identifier
+        /// </summary>
+        /// <param name="customer">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>> GetServiceCustomersByCustomerAsResponseAsync(
+            global::System.Guid customer,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomersCustomIdByCustomid.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomersCustomIdByCustomid.g.cs
index e8102b4..67e6520 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomersCustomIdByCustomid.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceCustomersCustomIdByCustomid.g.cs
@@ -18,5 +18,19 @@ public partial interface IPublicServiceClient
             global::System.Guid customId,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Retrieve customer by custom ID<br/>
+        /// Fetches the details of a customer based on their custom ID
+        /// </summary>
+        /// <param name="customId">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>> GetServiceCustomersCustomIdByCustomidAsResponseAsync(
+            global::System.Guid customId,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceLicenses.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceLicenses.g.cs
index f3e473a..1aff39e 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceLicenses.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceLicenses.g.cs
@@ -22,5 +22,23 @@ public partial interface IPublicServiceClient
             int? limit = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Retrieve a list of licenses<br/>
+        /// Retrieve a paginated list of all licenses for the company, including features, bitrates, formats, modes, and limits.
+        /// </summary>
+        /// <param name="offset">
+        /// Example: 0
+        /// </param>
+        /// <param name="limit">
+        /// Example: 25
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceLicensesResponse>> GetServiceLicensesAsResponseAsync(
+            int? offset = default,
+            int? limit = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceLicensesByLicense.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceLicensesByLicense.g.cs
index 9edb957..01e3a30 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceLicensesByLicense.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.GetServiceLicensesByLicense.g.cs
@@ -18,5 +18,19 @@ public partial interface IPublicServiceClient
             global::System.Guid license,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Retrieve details of a specific license<br/>
+        /// Retrieve details for a specific license including type, status, webhook configuration, track expiration time, feature access, and comprehensive limits.
+        /// </summary>
+        /// <param name="license">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.LicenseServiceResource>> GetServiceLicensesByLicenseAsResponseAsync(
+            global::System.Guid license,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PostServiceCustomers.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PostServiceCustomers.g.cs
index c788f83..adb022f 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PostServiceCustomers.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PostServiceCustomers.g.cs
@@ -21,6 +21,19 @@ public partial interface IPublicServiceClient
         /// Create a new customer<br/>
         /// Create a new customer account. Requires a unique custom_id (alphanumeric, max 255 chars). Returns customer_id and access_token for public API authentication.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>> PostServiceCustomersAsResponseAsync(
+
+            global::Mubert.PostServiceCustomersRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Create a new customer<br/>
+        /// Create a new customer account. Requires a unique custom_id (alphanumeric, max 255 chars). Returns customer_id and access_token for public API authentication.
+        /// </summary>
         /// <param name="customId">
         /// A unique identifier for the customer.<br/>
         /// Example: customer123
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PutServiceCustomersByCustomer.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PutServiceCustomersByCustomer.g.cs
index 9901604..6274891 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PutServiceCustomersByCustomer.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PutServiceCustomersByCustomer.g.cs
@@ -28,6 +28,23 @@ public partial interface IPublicServiceClient
         /// <param name="customer">
         /// Example: 123e4567-e89b-12d3-a456-426614174000
         /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>> PutServiceCustomersByCustomerAsResponseAsync(
+            global::System.Guid customer,
+
+            global::Mubert.PutServiceCustomersByCustomerRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Update an existing customer<br/>
+        /// Handles the update of an existing customer identified by their UUID
+        /// </summary>
+        /// <param name="customer">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
         /// <param name="customId">
         /// A unique identifier for the customer.<br/>
         /// Example: customer456
diff --git a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PutServiceLicensesByLicense.g.cs b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PutServiceLicensesByLicense.g.cs
index 0e967ea..9aaba36 100644
--- a/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PutServiceLicensesByLicense.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IPublicServiceClient.PutServiceLicensesByLicense.g.cs
@@ -28,6 +28,23 @@ public partial interface IPublicServiceClient
         /// <param name="license">
         /// Example: 123e4567-e89b-12d3-a456-426614174000
         /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.LicenseServiceResource>> PutServiceLicensesByLicenseAsResponseAsync(
+            global::System.Guid license,
+
+            global::Mubert.PutServiceLicensesByLicenseRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Update license<br/>
+        /// Update license parameters such as webhook URL and webhook enabled state. Webhooks receive track models when generation completes.
+        /// </summary>
+        /// <param name="license">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
         /// <param name="webhookUrl">
         /// The URL for the webhook.<br/>
         /// Example: https://example.com/webhook
diff --git a/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeBillingPortal.g.cs b/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeBillingPortal.g.cs
index 7319c5d..4666b45 100644
--- a/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeBillingPortal.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeBillingPortal.g.cs
@@ -21,6 +21,19 @@ public partial interface IServiceClient
         /// Stripe Billing Portal (GET)<br/>
         /// Create a Stripe billing portal session by company ID and license token.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceStripeBillingPortalResponse>> GetServiceStripeBillingPortalAsResponseAsync(
+
+            global::Mubert.GetServiceStripeBillingPortalRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Stripe Billing Portal (GET)<br/>
+        /// Create a Stripe billing portal session by company ID and license token.
+        /// </summary>
         /// <param name="companyId">
         /// Example: 550e8400-e29b-41d4-a716-446655440000
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeSubscriptionsBuy.g.cs b/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeSubscriptionsBuy.g.cs
index e154b06..6b24430 100644
--- a/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeSubscriptionsBuy.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeSubscriptionsBuy.g.cs
@@ -19,6 +19,18 @@ public partial interface IServiceClient
         /// <summary>
         /// Buy a subscription via GET (redirect flow). Creates a Stripe Checkout session and redirects to checkout URL.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceStripeSubscriptionsBuyResponse>> GetServiceStripeSubscriptionsBuyAsResponseAsync(
+
+            global::Mubert.GetServiceStripeSubscriptionsBuyRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Buy a subscription via GET (redirect flow). Creates a Stripe Checkout session and redirects to checkout URL.
+        /// </summary>
         /// <param name="companyName">
         /// Example: Acme Inc
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeSubscriptionsCancel.g.cs b/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeSubscriptionsCancel.g.cs
index 2054e8d..c7b9792 100644
--- a/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeSubscriptionsCancel.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IServiceClient.GetServiceStripeSubscriptionsCancel.g.cs
@@ -21,6 +21,19 @@ public partial interface IServiceClient
         /// Cancel Subscription (GET)<br/>
         /// Cancel a subscription via GET. Cancels at the end of the current billing period.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> GetServiceStripeSubscriptionsCancelAsResponseAsync(
+
+            global::Mubert.GetServiceStripeSubscriptionsCancelRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Cancel Subscription (GET)<br/>
+        /// Cancel a subscription via GET. Cancels at the end of the current billing period.
+        /// </summary>
         /// <param name="companyId">
         /// Example: 550e8400-e29b-41d4-a716-446655440000
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeBillingPortal.g.cs b/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeBillingPortal.g.cs
index 454bf50..b7754c2 100644
--- a/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeBillingPortal.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeBillingPortal.g.cs
@@ -21,6 +21,19 @@ public partial interface IServiceClient
         /// Stripe Billing Portal<br/>
         /// Create a Stripe billing portal session by company ID and license token.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostServiceStripeBillingPortalAsResponseAsync(
+
+            global::Mubert.PostServiceStripeBillingPortalRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Stripe Billing Portal<br/>
+        /// Create a Stripe billing portal session by company ID and license token.
+        /// </summary>
         /// <param name="companyId">
         /// Example: 550e8400-e29b-41d4-a716-446655440000
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeSubscriptionsBuy.g.cs b/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeSubscriptionsBuy.g.cs
index 637739c..7e8395b 100644
--- a/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeSubscriptionsBuy.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeSubscriptionsBuy.g.cs
@@ -19,6 +19,18 @@ public partial interface IServiceClient
         /// <summary>
         /// Buy a subscription. Creates a Stripe Checkout session and returns the checkout URL.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostServiceStripeSubscriptionsBuyResponse>> PostServiceStripeSubscriptionsBuyAsResponseAsync(
+
+            global::Mubert.PostServiceStripeSubscriptionsBuyRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Buy a subscription. Creates a Stripe Checkout session and returns the checkout URL.
+        /// </summary>
         /// <param name="companyName">
         /// Example: Acme Inc
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeSubscriptionsCancel.g.cs b/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeSubscriptionsCancel.g.cs
index 43210a6..2aeb088 100644
--- a/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeSubscriptionsCancel.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.IServiceClient.PostServiceStripeSubscriptionsCancel.g.cs
@@ -21,6 +21,19 @@ public partial interface IServiceClient
         /// Cancel Subscription<br/>
         /// Cancel a subscription by company ID and license token. Cancels at the end of the current billing period.
         /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostServiceStripeSubscriptionsCancelAsResponseAsync(
+
+            global::Mubert.PostServiceStripeSubscriptionsCancelRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default);
+        /// <summary>
+        /// Cancel Subscription<br/>
+        /// Cancel a subscription by company ID and license token. Cancels at the end of the current billing period.
+        /// </summary>
         /// <param name="companyId">
         /// Example: 550e8400-e29b-41d4-a716-446655440000
         /// </param>
diff --git a/src/libs/Mubert/Generated/Mubert.MubertClient.g.cs b/src/libs/Mubert/Generated/Mubert.MubertClient.g.cs
index bd7a7e5..509272b 100644
--- a/src/libs/Mubert/Generated/Mubert.MubertClient.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.MubertClient.g.cs
@@ -46,7 +46,7 @@ public sealed partial class MubertClient : global::Mubert.IMubertClient, global:
         /// <summary>
         /// Public.
         /// </summary>
-        public PublicClient Public => new PublicClient(HttpClient, authorizations: Authorizations, options: Options)
+        public PublicClient Public => new PublicClient(HttpClient, baseUri: null, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -55,7 +55,7 @@ public sealed partial class MubertClient : global::Mubert.IMubertClient, global:
         /// <summary>
         /// Public Service.
         /// </summary>
-        public PublicServiceClient PublicService => new PublicServiceClient(HttpClient, authorizations: Authorizations, options: Options)
+        public PublicServiceClient PublicService => new PublicServiceClient(HttpClient, baseUri: null, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -64,7 +64,7 @@ public sealed partial class MubertClient : global::Mubert.IMubertClient, global:
         /// <summary>
         /// Service.
         /// </summary>
-        public ServiceClient Service => new ServiceClient(HttpClient, authorizations: Authorizations, options: Options)
+        public ServiceClient Service => new ServiceClient(HttpClient, baseUri: null, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -103,10 +103,10 @@ public MubertClient(
         /// <param name="options">Client-wide request defaults such as headers, query parameters, retries, and timeout.</param>
         /// <param name="disposeHttpClient">Dispose the HttpClient when the instance is disposed. True by default.</param>
         public MubertClient(
-            global::System.Net.Http.HttpClient? httpClient = null,
-            global::System.Uri? baseUri = null,
-            global::System.Collections.Generic.List<global::Mubert.EndPointAuthorization>? authorizations = null,
-            global::Mubert.AutoSDKClientOptions? options = null,
+            global::System.Net.Http.HttpClient? httpClient,
+            global::System.Uri? baseUri,
+            global::System.Collections.Generic.List<global::Mubert.EndPointAuthorization>? authorizations,
+            global::Mubert.AutoSDKClientOptions? options,
             bool disposeHttpClient = true)
         {
 
diff --git a/src/libs/Mubert/Generated/Mubert.OptionsSupport.g.cs b/src/libs/Mubert/Generated/Mubert.OptionsSupport.g.cs
index 8488579..8a37368 100644
--- a/src/libs/Mubert/Generated/Mubert.OptionsSupport.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.OptionsSupport.g.cs
@@ -101,9 +101,45 @@ public sealed class AutoSDKRetryOptions
         public int MaxAttempts { get; set; } = 1;
 
         /// <summary>
-        /// Optional fixed delay between retry attempts.
+        /// Optional fixed delay between retry attempts. When set, this takes precedence over exponential backoff.
         /// </summary>
         public global::System.TimeSpan? Delay { get; set; }
+
+        /// <summary>
+        /// Initial exponential backoff delay used when <see cref="Delay"/> is not set.
+        /// </summary>
+        public global::System.TimeSpan InitialDelay { get; set; } = global::System.TimeSpan.FromSeconds(1);
+
+        /// <summary>
+        /// Maximum retry delay after applying retry headers, backoff, and jitter.
+        /// </summary>
+        public global::System.TimeSpan MaxDelay { get; set; } = global::System.TimeSpan.FromSeconds(30);
+
+        /// <summary>
+        /// Multiplier applied to exponential backoff after each failed attempt.
+        /// Values below 1 are normalized to 1.
+        /// </summary>
+        public double BackoffMultiplier { get; set; } = 2D;
+
+        /// <summary>
+        /// Randomizes computed backoff by plus or minus this ratio. Values are clamped to 0..1.
+        /// </summary>
+        public double JitterRatio { get; set; } = 0.2D;
+
+        /// <summary>
+        /// Whether Retry-After response headers should control retry delay when present.
+        /// </summary>
+        public bool UseRetryAfterHeader { get; set; } = true;
+
+        /// <summary>
+        /// Whether a rate-limit reset response header should control retry delay when present.
+        /// </summary>
+        public bool UseRateLimitResetHeader { get; set; }
+
+        /// <summary>
+        /// Optional provider-specific rate-limit reset header name. Values may be Unix seconds or an HTTP date.
+        /// </summary>
+        public string? RateLimitResetHeaderName { get; set; } = "X-RateLimit-Reset";
     }
 
 
@@ -231,6 +267,16 @@ public sealed class AutoSDKHookContext
         /// </summary>
         public bool WillRetry { get; set; }
 
+        /// <summary>
+        /// The computed retry delay when <see cref="WillRetry"/> is true.
+        /// </summary>
+        public global::System.TimeSpan? RetryDelay { get; set; }
+
+        /// <summary>
+        /// A short retry reason such as exception or status:429.
+        /// </summary>
+        public string RetryReason { get; set; } = string.Empty;
+
         /// <summary>
         /// The effective cancellation token for the current request attempt.
         /// </summary>
@@ -254,6 +300,8 @@ internal static class AutoSDKRequestOptionsSupport
             int attempt,
             int maxAttempts,
             bool willRetry,
+            global::System.TimeSpan? retryDelay,
+            string retryReason,
             global::System.Threading.CancellationToken cancellationToken)
         {
             return new global::Mubert.AutoSDKHookContext
@@ -271,6 +319,8 @@ internal static class AutoSDKRequestOptionsSupport
                 Attempt = attempt,
                 MaxAttempts = maxAttempts,
                 WillRetry = willRetry,
+                RetryDelay = retryDelay,
+                RetryReason = retryReason ?? string.Empty,
                 CancellationToken = cancellationToken,
             };
         }
@@ -338,19 +388,188 @@ internal static int GetMaxAttempts(
             return maxAttempts < 1 ? 1 : maxAttempts;
         }
 
-        internal static async global::System.Threading.Tasks.Task DelayBeforeRetryAsync(
+        internal static global::System.TimeSpan GetRetryDelay(
             global::Mubert.AutoSDKClientOptions clientOptions,
             global::Mubert.AutoSDKRequestOptions? requestOptions,
+            global::System.Net.Http.HttpResponseMessage? response,
+            int attempt)
+        {
+            var retryOptions = requestOptions?.Retry ?? clientOptions.Retry ?? new global::Mubert.AutoSDKRetryOptions();
+
+            if (retryOptions.UseRetryAfterHeader &&
+                TryGetRetryAfterDelay(response, out var retryAfterDelay))
+            {
+                return ClampRetryDelay(retryAfterDelay, retryOptions);
+            }
+
+            if (retryOptions.UseRateLimitResetHeader &&
+                TryGetRateLimitResetDelay(response, retryOptions.RateLimitResetHeaderName, out var rateLimitResetDelay))
+            {
+                return ClampRetryDelay(rateLimitResetDelay, retryOptions);
+            }
+
+            if (retryOptions.Delay.HasValue)
+            {
+                return ClampRetryDelay(retryOptions.Delay.Value, retryOptions);
+            }
+
+            var initialDelay = retryOptions.InitialDelay;
+            if (initialDelay <= global::System.TimeSpan.Zero)
+            {
+                return global::System.TimeSpan.Zero;
+            }
+
+            var multiplier = retryOptions.BackoffMultiplier < 1D ? 1D : retryOptions.BackoffMultiplier;
+            var exponent = attempt <= 1 ? 0 : attempt - 1;
+            var delayMilliseconds = initialDelay.TotalMilliseconds * global::System.Math.Pow(multiplier, exponent);
+            if (double.IsNaN(delayMilliseconds) || double.IsInfinity(delayMilliseconds) || delayMilliseconds < 0D)
+            {
+                delayMilliseconds = 0D;
+            }
+
+            var delay = global::System.TimeSpan.FromMilliseconds(delayMilliseconds);
+            delay = ApplyJitter(delay, retryOptions.JitterRatio);
+            return ClampRetryDelay(delay, retryOptions);
+        }
+
+        internal static async global::System.Threading.Tasks.Task DelayBeforeRetryAsync(
+            global::System.TimeSpan retryDelay,
             global::System.Threading.CancellationToken cancellationToken)
         {
-            var delay = requestOptions?.Retry?.Delay ??
-                        clientOptions.Retry?.Delay;
-            if (!delay.HasValue || delay.Value <= global::System.TimeSpan.Zero)
+            if (retryDelay <= global::System.TimeSpan.Zero)
             {
                 return;
             }
 
-            await global::System.Threading.Tasks.Task.Delay(delay.Value, cancellationToken).ConfigureAwait(false);
+            await global::System.Threading.Tasks.Task.Delay(retryDelay, cancellationToken).ConfigureAwait(false);
+        }
+
+        private static bool TryGetRetryAfterDelay(
+            global::System.Net.Http.HttpResponseMessage? response,
+            out global::System.TimeSpan delay)
+        {
+            delay = global::System.TimeSpan.Zero;
+            var retryAfter = response?.Headers.RetryAfter;
+            if (retryAfter == null)
+            {
+                return false;
+            }
+
+            if (retryAfter.Delta.HasValue)
+            {
+                delay = retryAfter.Delta.Value;
+                return delay > global::System.TimeSpan.Zero;
+            }
+
+            if (retryAfter.Date.HasValue)
+            {
+                delay = retryAfter.Date.Value - global::System.DateTimeOffset.UtcNow;
+                return delay > global::System.TimeSpan.Zero;
+            }
+
+            return false;
+        }
+
+        private static bool TryGetRateLimitResetDelay(
+            global::System.Net.Http.HttpResponseMessage? response,
+            string? headerName,
+            out global::System.TimeSpan delay)
+        {
+            delay = global::System.TimeSpan.Zero;
+            if (response == null || string.IsNullOrWhiteSpace(headerName))
+            {
+                return false;
+            }
+
+            if (!response.Headers.TryGetValues(headerName, out var values) &&
+                (response.Content?.Headers == null || !response.Content.Headers.TryGetValues(headerName, out values)))
+            {
+                return false;
+            }
+
+            var value = global::System.Linq.Enumerable.FirstOrDefault(values);
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                return false;
+            }
+
+            value = value.Trim();
+            if (long.TryParse(
+                value,
+                global::System.Globalization.NumberStyles.Integer,
+                global::System.Globalization.CultureInfo.InvariantCulture,
+                out var unixSeconds))
+            {
+                delay = global::System.DateTimeOffset.FromUnixTimeSeconds(unixSeconds) - global::System.DateTimeOffset.UtcNow;
+                return delay > global::System.TimeSpan.Zero;
+            }
+
+            if (global::System.DateTimeOffset.TryParse(
+                value,
+                global::System.Globalization.CultureInfo.InvariantCulture,
+                global::System.Globalization.DateTimeStyles.AssumeUniversal | global::System.Globalization.DateTimeStyles.AdjustToUniversal,
+                out var resetAt))
+            {
+                delay = resetAt - global::System.DateTimeOffset.UtcNow;
+                return delay > global::System.TimeSpan.Zero;
+            }
+
+            return false;
+        }
+
+        private static global::System.TimeSpan ApplyJitter(
+            global::System.TimeSpan delay,
+            double jitterRatio)
+        {
+            if (delay <= global::System.TimeSpan.Zero || jitterRatio <= 0D)
+            {
+                return delay;
+            }
+
+            if (jitterRatio > 1D)
+            {
+                jitterRatio = 1D;
+            }
+
+            var sample = NextJitterSample();
+            var multiplier = 1D - jitterRatio + (sample * jitterRatio * 2D);
+            var milliseconds = delay.TotalMilliseconds * multiplier;
+            if (double.IsNaN(milliseconds) || double.IsInfinity(milliseconds) || milliseconds < 0D)
+            {
+                milliseconds = 0D;
+            }
+
+            return global::System.TimeSpan.FromMilliseconds(milliseconds);
+        }
+
+        private static double NextJitterSample()
+        {
+            var bytes = new byte[8];
+            using (var randomNumberGenerator = global::System.Security.Cryptography.RandomNumberGenerator.Create())
+            {
+                randomNumberGenerator.GetBytes(bytes);
+            }
+
+            var value = global::System.BitConverter.ToUInt64(bytes, 0);
+            return value / (double)ulong.MaxValue;
+        }
+
+        private static global::System.TimeSpan ClampRetryDelay(
+            global::System.TimeSpan delay,
+            global::Mubert.AutoSDKRetryOptions retryOptions)
+        {
+            if (delay <= global::System.TimeSpan.Zero)
+            {
+                return global::System.TimeSpan.Zero;
+            }
+
+            var maxDelay = retryOptions.MaxDelay;
+            if (maxDelay > global::System.TimeSpan.Zero && delay > maxDelay)
+            {
+                return maxDelay;
+            }
+
+            return delay;
         }
 
         internal static bool ShouldRetryStatusCode(
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicMusicLibraryParams.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicMusicLibraryParams.g.cs
index b743f4e..57ae3dd 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicMusicLibraryParams.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicMusicLibraryParams.g.cs
@@ -111,6 +111,76 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
             global::Mubert.TrackModeEnum? mode = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicMusicLibraryParamsAsResponseAsync(
+                bpm: bpm,
+                key: key,
+                genres: genres,
+                moods: moods,
+                activities: activities,
+                playlists: playlists,
+                instruments: instruments,
+                themes: themes,
+                duration: duration,
+                mode: mode,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Get music library filter parameters<br/>
+        /// Retrieve available filter parameters and track counts for the music library. Use filters to refine results — multiple filters are combined with logical AND.
+        /// </summary>
+        /// <param name="bpm">
+        /// Example: 120
+        /// </param>
+        /// <param name="key">
+        /// Key-Scale for a track.<br/>
+        /// Example: C#
+        /// </param>
+        /// <param name="genres">
+        /// Example: Rock
+        /// </param>
+        /// <param name="moods">
+        /// Example: Happy
+        /// </param>
+        /// <param name="activities">
+        /// Example: Minimal 170
+        /// </param>
+        /// <param name="playlists">
+        /// Example: Chill Vibes
+        /// </param>
+        /// <param name="instruments">
+        /// Example: Guitar
+        /// </param>
+        /// <param name="themes">
+        /// Example: Corporate
+        /// </param>
+        /// <param name="duration">
+        /// Example: 180
+        /// </param>
+        /// <param name="mode">
+        /// Enumeration representing different modes of a track.<br/>
+        /// Example: loop
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>>> GetPublicMusicLibraryParamsAsResponseAsync(
+            int? bpm = default,
+            global::Mubert.TrackKeyScaleEnum? key = default,
+            string? genres = default,
+            string? moods = default,
+            string? activities = default,
+            string? playlists = default,
+            string? instruments = default,
+            string? themes = default,
+            int? duration = default,
+            global::Mubert.TrackModeEnum? mode = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -149,9 +219,10 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/music-library/params",
-                                baseUri: HttpClient.BaseAddress); 
+                                baseUri: HttpClient.BaseAddress);
                             __pathBuilder
                                 .AddOptionalParameter("bpm", bpm?.ToString())
                                 .AddOptionalParameter("key", key?.ToValueString())
@@ -162,7 +233,7 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                                 .AddOptionalParameter("instruments", instruments)
                                 .AddOptionalParameter("themes", themes)
                                 .AddOptionalParameter("duration", duration?.ToString())
-                                .AddOptionalParameter("mode", mode?.ToValueString()) 
+                                .AddOptionalParameter("mode", mode?.ToValueString())
                                 ;
                             var __path = __pathBuilder.ToString();
                 __path = global::Mubert.AutoSDKRequestOptionsSupport.AppendQueryParameters(
@@ -243,6 +314,8 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -253,6 +326,11 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -270,6 +348,8 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -279,8 +359,7 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -289,6 +368,11 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -305,14 +389,15 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -352,6 +437,8 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -372,6 +459,8 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -505,9 +594,13 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        (global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>), JsonSerializerContext) ??
+                                    var __value = (global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>), JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -535,9 +628,13 @@ partial void ProcessGetPublicMusicLibraryParamsResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        (global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>), JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = (global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>), JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::System.Collections.Generic.IList<global::Mubert.GetPublicMusicLibraryParamsResponseItem>>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicMusicLibraryTracks.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicMusicLibraryTracks.g.cs
index 49be357..98b064e 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicMusicLibraryTracks.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicMusicLibraryTracks.g.cs
@@ -135,6 +135,96 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
             global::Mubert.TrackModeEnum? mode = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicMusicLibraryTracksAsResponseAsync(
+                offset: offset,
+                limit: limit,
+                order: order,
+                orderBy: orderBy,
+                bpm: bpm,
+                key: key,
+                genres: genres,
+                moods: moods,
+                activities: activities,
+                playlists: playlists,
+                instruments: instruments,
+                themes: themes,
+                duration: duration,
+                mode: mode,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// List music library tracks<br/>
+        /// Retrieve a paginated list of pre-generated music library tracks with optional filtering by genre, mood, BPM, key, and other parameters.
+        /// </summary>
+        /// <param name="offset">
+        /// Example: 0
+        /// </param>
+        /// <param name="limit">
+        /// Example: 25
+        /// </param>
+        /// <param name="order">
+        /// Example: asc
+        /// </param>
+        /// <param name="orderBy">
+        /// Example: created_at
+        /// </param>
+        /// <param name="bpm">
+        /// Example: 120
+        /// </param>
+        /// <param name="key">
+        /// Key-Scale for a track.<br/>
+        /// Example: C#
+        /// </param>
+        /// <param name="genres">
+        /// Example: Rock
+        /// </param>
+        /// <param name="moods">
+        /// Example: Happy
+        /// </param>
+        /// <param name="activities">
+        /// Example: Minimal 170
+        /// </param>
+        /// <param name="playlists">
+        /// Example: Chill Vibes
+        /// </param>
+        /// <param name="instruments">
+        /// Example: Guitar
+        /// </param>
+        /// <param name="themes">
+        /// Example: Corporate
+        /// </param>
+        /// <param name="duration">
+        /// Example: 180
+        /// </param>
+        /// <param name="mode">
+        /// Enumeration representing different modes of a track.<br/>
+        /// Example: loop
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicMusicLibraryTracksResponse>> GetPublicMusicLibraryTracksAsResponseAsync(
+            int? offset = default,
+            int? limit = default,
+            global::Mubert.GetPublicMusicLibraryTracksOrder? order = default,
+            string? orderBy = default,
+            int? bpm = default,
+            global::Mubert.TrackKeyScaleEnum? key = default,
+            string? genres = default,
+            string? moods = default,
+            string? activities = default,
+            string? playlists = default,
+            string? instruments = default,
+            string? themes = default,
+            int? duration = default,
+            global::Mubert.TrackModeEnum? mode = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -177,9 +267,10 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/music-library/tracks",
-                                baseUri: HttpClient.BaseAddress); 
+                                baseUri: HttpClient.BaseAddress);
                             __pathBuilder
                                 .AddOptionalParameter("offset", offset?.ToString())
                                 .AddOptionalParameter("limit", limit?.ToString())
@@ -194,7 +285,7 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                                 .AddOptionalParameter("instruments", instruments)
                                 .AddOptionalParameter("themes", themes)
                                 .AddOptionalParameter("duration", duration?.ToString())
-                                .AddOptionalParameter("mode", mode?.ToValueString()) 
+                                .AddOptionalParameter("mode", mode?.ToValueString())
                                 ;
                             var __path = __pathBuilder.ToString();
                 __path = global::Mubert.AutoSDKRequestOptionsSupport.AppendQueryParameters(
@@ -279,6 +370,8 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -289,6 +382,11 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -306,6 +404,8 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -315,8 +415,7 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -325,6 +424,11 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -341,14 +445,15 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -388,6 +493,8 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -408,6 +515,8 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -541,9 +650,13 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetPublicMusicLibraryTracksResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetPublicMusicLibraryTracksResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicMusicLibraryTracksResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -571,9 +684,13 @@ partial void ProcessGetPublicMusicLibraryTracksResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetPublicMusicLibraryTracksResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetPublicMusicLibraryTracksResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicMusicLibraryTracksResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPlaylists.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPlaylists.g.cs
index 9504281..bc738f2 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPlaylists.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPlaylists.g.cs
@@ -49,6 +49,24 @@ partial void ProcessGetPublicPlaylistsResponseContent(
         public async global::System.Threading.Tasks.Task<global::Mubert.GetPublicPlaylistsResponse> GetPublicPlaylistsAsync(
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicPlaylistsAsResponseAsync(
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// List playlists<br/>
+        /// Retrieve all available music channels, groups, and categories. Each entry includes a playlist_index identifier, category, group, channel name, and available parameters (BPM range, keys).
+        /// </summary>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPlaylistsResponse>> GetPublicPlaylistsAsResponseAsync(
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -77,6 +95,7 @@ partial void ProcessGetPublicPlaylistsResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/playlists",
                                 baseUri: HttpClient.BaseAddress);
@@ -149,6 +168,8 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -159,6 +180,11 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -176,6 +202,8 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -185,8 +213,7 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -195,6 +222,11 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -211,14 +243,15 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -258,6 +291,8 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -278,6 +313,8 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -378,9 +415,13 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetPublicPlaylistsResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetPublicPlaylistsResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPlaylistsResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -408,9 +449,13 @@ partial void ProcessGetPublicPlaylistsResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetPublicPlaylistsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetPublicPlaylistsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPlaylistsResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPrices.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPrices.g.cs
index 6ab9e93..f1bd53e 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPrices.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPrices.g.cs
@@ -54,6 +54,28 @@ partial void ProcessGetPublicPricesResponseContent(
             global::Mubert.LanguageEnum? lang = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicPricesAsResponseAsync(
+                lang: lang,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Retrieve a list of available prices with their options, limits, and Stripe prices
+        /// </summary>
+        /// <param name="lang">
+        /// Languages
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPricesResponse>> GetPublicPricesAsResponseAsync(
+            global::Mubert.LanguageEnum? lang = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -83,11 +105,12 @@ partial void ProcessGetPublicPricesResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/prices",
-                                baseUri: HttpClient.BaseAddress); 
+                                baseUri: HttpClient.BaseAddress);
                             __pathBuilder
-                                .AddOptionalParameter("lang", lang?.ToValueString()) 
+                                .AddOptionalParameter("lang", lang?.ToValueString())
                                 ;
                             var __path = __pathBuilder.ToString();
                 __path = global::Mubert.AutoSDKRequestOptionsSupport.AppendQueryParameters(
@@ -159,6 +182,8 @@ partial void ProcessGetPublicPricesResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -169,6 +194,11 @@ partial void ProcessGetPublicPricesResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -186,6 +216,8 @@ partial void ProcessGetPublicPricesResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -195,8 +227,7 @@ partial void ProcessGetPublicPricesResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -205,6 +236,11 @@ partial void ProcessGetPublicPricesResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -221,14 +257,15 @@ partial void ProcessGetPublicPricesResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -268,6 +305,8 @@ partial void ProcessGetPublicPricesResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -288,6 +327,8 @@ partial void ProcessGetPublicPricesResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
 
@@ -312,9 +353,13 @@ partial void ProcessGetPublicPricesResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetPublicPricesResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetPublicPricesResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPricesResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -342,9 +387,13 @@ partial void ProcessGetPublicPricesResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetPublicPricesResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetPublicPricesResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPricesResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPricesByPrice.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPricesByPrice.g.cs
index c927958..6037ea8 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPricesByPrice.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicPricesByPrice.g.cs
@@ -60,6 +60,33 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
             global::Mubert.LanguageEnum? lang = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicPricesByPriceAsResponseAsync(
+                price: price,
+                lang: lang,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Retrieve a single price by ID with its options, limits, and Stripe prices
+        /// </summary>
+        /// <param name="price">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="lang">
+        /// Languages
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPricesByPriceResponse>> GetPublicPricesByPriceAsResponseAsync(
+            global::System.Guid price,
+            global::Mubert.LanguageEnum? lang = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -90,11 +117,12 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/public/prices/{price}",
-                                baseUri: HttpClient.BaseAddress); 
+                                baseUri: HttpClient.BaseAddress);
                             __pathBuilder
-                                .AddOptionalParameter("lang", lang?.ToValueString()) 
+                                .AddOptionalParameter("lang", lang?.ToValueString())
                                 ;
                             var __path = __pathBuilder.ToString();
                 __path = global::Mubert.AutoSDKRequestOptionsSupport.AppendQueryParameters(
@@ -167,6 +195,8 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -177,6 +207,11 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -194,6 +229,8 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -203,8 +240,7 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -213,6 +249,11 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -229,14 +270,15 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -276,6 +318,8 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -296,6 +340,8 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Price not found
@@ -358,9 +404,13 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetPublicPricesByPriceResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetPublicPricesByPriceResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPricesByPriceResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -388,9 +438,13 @@ partial void ProcessGetPublicPricesByPriceResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetPublicPricesByPriceResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetPublicPricesByPriceResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicPricesByPriceResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicStreamingGetLink.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicStreamingGetLink.g.cs
index b255dce..7667217 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicStreamingGetLink.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicStreamingGetLink.g.cs
@@ -75,6 +75,46 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
             global::Mubert.StreamingTypeEnum? type = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicStreamingGetLinkAsResponseAsync(
+                playlistIndex: playlistIndex,
+                bitrate: bitrate,
+                intensity: intensity,
+                type: type,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Get streaming link<br/>
+        /// Generate a streaming URL for continuous music playback. The returned link can be used in any audio player that supports HTTP streaming or WebRTC.
+        /// </summary>
+        /// <param name="playlistIndex">
+        /// Example: 1.0.0
+        /// </param>
+        /// <param name="bitrate">
+        /// Enumeration representing different track bitrates.<br/>
+        /// Example: 320
+        /// </param>
+        /// <param name="intensity">
+        /// Enumeration representing different intensity levels of a track.<br/>
+        /// Example: medium
+        /// </param>
+        /// <param name="type">
+        /// Streaming Type Enum
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicStreamingGetLinkResponse>> GetPublicStreamingGetLinkAsResponseAsync(
+            string playlistIndex,
+            int? bitrate = default,
+            global::Mubert.TrackIntensityEnum? intensity = default,
+            global::Mubert.StreamingTypeEnum? type = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -107,14 +147,15 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/streaming/get-link",
-                                baseUri: HttpClient.BaseAddress); 
+                                baseUri: HttpClient.BaseAddress);
                             __pathBuilder
                                 .AddRequiredParameter("playlist_index", playlistIndex)
                                 .AddOptionalParameter("bitrate", bitrate?.ToString())
                                 .AddOptionalParameter("intensity", intensity?.ToValueString())
-                                .AddOptionalParameter("type", type?.ToValueString()) 
+                                .AddOptionalParameter("type", type?.ToValueString())
                                 ;
                             var __path = __pathBuilder.ToString();
                 __path = global::Mubert.AutoSDKRequestOptionsSupport.AppendQueryParameters(
@@ -189,6 +230,8 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -199,6 +242,11 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -216,6 +264,8 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -225,8 +275,7 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -235,6 +284,11 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -251,14 +305,15 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -298,6 +353,8 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -318,6 +375,8 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -418,9 +477,13 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetPublicStreamingGetLinkResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetPublicStreamingGetLinkResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicStreamingGetLinkResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -448,9 +511,13 @@ partial void ProcessGetPublicStreamingGetLinkResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetPublicStreamingGetLinkResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetPublicStreamingGetLinkResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicStreamingGetLinkResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicSubscriptionsBuy.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicSubscriptionsBuy.g.cs
index 8a882e7..8c7bd8d 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicSubscriptionsBuy.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicSubscriptionsBuy.g.cs
@@ -50,6 +50,28 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Mubert.GetPublicSubscriptionsBuyResponse> GetPublicSubscriptionsBuyAsync(
 
+            global::Mubert.GetPublicSubscriptionsBuyRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicSubscriptionsBuyAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Buy a subscription via GET (redirect flow). Creates a Stripe Checkout session and redirects to checkout URL.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicSubscriptionsBuyResponse>> GetPublicSubscriptionsBuyAsResponseAsync(
+
             global::Mubert.GetPublicSubscriptionsBuyRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -84,6 +106,7 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/subscriptions/buy",
                                 baseUri: HttpClient.BaseAddress);
@@ -163,6 +186,8 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -173,6 +198,11 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -190,6 +220,8 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -199,8 +231,7 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -209,6 +240,11 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -225,14 +261,15 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -272,6 +309,8 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -292,6 +331,8 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -420,9 +461,13 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetPublicSubscriptionsBuyResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetPublicSubscriptionsBuyResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicSubscriptionsBuyResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -450,9 +495,13 @@ partial void ProcessGetPublicSubscriptionsBuyResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetPublicSubscriptionsBuyResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetPublicSubscriptionsBuyResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicSubscriptionsBuyResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicSubscriptionsCancel.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicSubscriptionsCancel.g.cs
index bdf8ffa..b364bd4 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicSubscriptionsCancel.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicSubscriptionsCancel.g.cs
@@ -46,6 +46,27 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task GetPublicSubscriptionsCancelAsync(
 
+            global::Mubert.GetPublicSubscriptionsCancelRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await GetPublicSubscriptionsCancelAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Cancel Subscription (GET)<br/>
+        /// Cancel a subscription via GET. Cancels at the end of the current billing period.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> GetPublicSubscriptionsCancelAsResponseAsync(
+
             global::Mubert.GetPublicSubscriptionsCancelRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -80,6 +101,7 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/subscriptions/cancel",
                                 baseUri: HttpClient.BaseAddress);
@@ -159,6 +181,8 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -169,6 +193,11 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -186,6 +215,8 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -195,8 +226,7 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -205,6 +235,11 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -221,14 +256,15 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -268,6 +304,8 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -288,6 +326,8 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -374,6 +414,10 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -395,6 +439,10 @@ partial void ProcessGetPublicSubscriptionsCancelResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracks.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracks.g.cs
index 4fd4616..71e9300 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracks.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracks.g.cs
@@ -73,6 +73,44 @@ partial void ProcessGetPublicTracksResponseContent(
             string? orderBy = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicTracksAsResponseAsync(
+                offset: offset,
+                limit: limit,
+                order: order,
+                orderBy: orderBy,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// List tracks<br/>
+        /// Retrieve a paginated list of tracks generated by the customer.
+        /// </summary>
+        /// <param name="offset">
+        /// Example: 0
+        /// </param>
+        /// <param name="limit">
+        /// Example: 25
+        /// </param>
+        /// <param name="order">
+        /// Example: asc
+        /// </param>
+        /// <param name="orderBy">
+        /// Example: created_at
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksResponse>> GetPublicTracksAsResponseAsync(
+            int? offset = default,
+            int? limit = default,
+            global::Mubert.GetPublicTracksOrder? order = default,
+            string? orderBy = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -105,14 +143,15 @@ partial void ProcessGetPublicTracksResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/tracks",
-                                baseUri: HttpClient.BaseAddress); 
+                                baseUri: HttpClient.BaseAddress);
                             __pathBuilder
                                 .AddOptionalParameter("offset", offset?.ToString())
                                 .AddOptionalParameter("limit", limit?.ToString())
                                 .AddOptionalParameter("order", order?.ToValueString())
-                                .AddOptionalParameter("order_by", orderBy) 
+                                .AddOptionalParameter("order_by", orderBy)
                                 ;
                             var __path = __pathBuilder.ToString();
                 __path = global::Mubert.AutoSDKRequestOptionsSupport.AppendQueryParameters(
@@ -187,6 +226,8 @@ partial void ProcessGetPublicTracksResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -197,6 +238,11 @@ partial void ProcessGetPublicTracksResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -214,6 +260,8 @@ partial void ProcessGetPublicTracksResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -223,8 +271,7 @@ partial void ProcessGetPublicTracksResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -233,6 +280,11 @@ partial void ProcessGetPublicTracksResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -249,14 +301,15 @@ partial void ProcessGetPublicTracksResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -296,6 +349,8 @@ partial void ProcessGetPublicTracksResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -316,6 +371,8 @@ partial void ProcessGetPublicTracksResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -449,9 +506,13 @@ partial void ProcessGetPublicTracksResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetPublicTracksResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetPublicTracksResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -479,9 +540,13 @@ partial void ProcessGetPublicTracksResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetPublicTracksResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetPublicTracksResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracksByTrack.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracksByTrack.g.cs
index 1e3b861..39ab0ef 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracksByTrack.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracksByTrack.g.cs
@@ -55,6 +55,29 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
             global::System.Guid track,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicTracksByTrackAsResponseAsync(
+                track: track,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Get track by ID<br/>
+        /// Retrieve specific track details including generation status, download URLs, and expiration times.
+        /// </summary>
+        /// <param name="track">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksByTrackResponse>> GetPublicTracksByTrackAsResponseAsync(
+            global::System.Guid track,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -84,6 +107,7 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/public/tracks/{track}",
                                 baseUri: HttpClient.BaseAddress);
@@ -157,6 +181,8 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -167,6 +193,11 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -184,6 +215,8 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -193,8 +226,7 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -203,6 +235,11 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -219,14 +256,15 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -266,6 +304,8 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -286,6 +326,8 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -457,9 +499,13 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetPublicTracksByTrackResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetPublicTracksByTrackResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksByTrackResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -487,9 +533,13 @@ partial void ProcessGetPublicTracksByTrackResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetPublicTracksByTrackResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetPublicTracksByTrackResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksByTrackResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracksSessionBySessionId.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracksSessionBySessionId.g.cs
index 6fba293..666eaea 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracksSessionBySessionId.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.GetPublicTracksSessionBySessionId.g.cs
@@ -59,6 +59,32 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
             string sessionId,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetPublicTracksSessionBySessionIdAsResponseAsync(
+                track: track,
+                sessionId: sessionId,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Get track by session ID<br/>
+        /// Retrieve specific track details by session ID including generation status, download URLs, and expiration times.
+        /// </summary>
+        /// <param name="track">
+        /// Example: 4b19470aec7446d0a8e3c05d06b23ce2
+        /// </param>
+        /// <param name="sessionId"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksSessionBySessionIdResponse>> GetPublicTracksSessionBySessionIdAsResponseAsync(
+            string track,
+            string sessionId,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -89,6 +115,7 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/public/tracks/session/{sessionId}",
                                 baseUri: HttpClient.BaseAddress);
@@ -163,6 +190,8 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -173,6 +202,11 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -190,6 +224,8 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -199,8 +235,7 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -209,6 +244,11 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -225,14 +265,15 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -272,6 +313,8 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -292,6 +335,8 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -463,9 +508,13 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetPublicTracksSessionBySessionIdResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetPublicTracksSessionBySessionIdResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksSessionBySessionIdResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -493,9 +542,13 @@ partial void ProcessGetPublicTracksSessionBySessionIdResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetPublicTracksSessionBySessionIdResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetPublicTracksSessionBySessionIdResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetPublicTracksSessionBySessionIdResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingRestart.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingRestart.g.cs
index 64dfae6..3d53a3b 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingRestart.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingRestart.g.cs
@@ -46,6 +46,27 @@ partial void ProcessPostPublicStreamingRestartResponse(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PostPublicStreamingRestartAsync(
 
+            object request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await PostPublicStreamingRestartAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Restart stream<br/>
+        /// Restart the stream so that a different track is played using the same streaming URL.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicStreamingRestartAsResponseAsync(
+
             object request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -80,6 +101,7 @@ partial void ProcessPostPublicStreamingRestartResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/streaming/restart",
                                 baseUri: HttpClient.BaseAddress);
@@ -159,6 +181,8 @@ partial void ProcessPostPublicStreamingRestartResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -169,6 +193,11 @@ partial void ProcessPostPublicStreamingRestartResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -186,6 +215,8 @@ partial void ProcessPostPublicStreamingRestartResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -195,8 +226,7 @@ partial void ProcessPostPublicStreamingRestartResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -205,6 +235,11 @@ partial void ProcessPostPublicStreamingRestartResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -221,14 +256,15 @@ partial void ProcessPostPublicStreamingRestartResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -268,6 +304,8 @@ partial void ProcessPostPublicStreamingRestartResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -288,6 +326,8 @@ partial void ProcessPostPublicStreamingRestartResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -384,6 +424,10 @@ partial void ProcessPostPublicStreamingRestartResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -405,6 +449,10 @@ partial void ProcessPostPublicStreamingRestartResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingSetIntensity.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingSetIntensity.g.cs
index 097db27..25fb324 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingSetIntensity.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingSetIntensity.g.cs
@@ -46,6 +46,27 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PostPublicStreamingSetIntensityAsync(
 
+            global::Mubert.PostPublicStreamingSetIntensityRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await PostPublicStreamingSetIntensityAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Set stream intensity<br/>
+        /// Dynamically adjust the arrangement complexity during streaming. Changes occur seamlessly without stream interruption.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicStreamingSetIntensityAsResponseAsync(
+
             global::Mubert.PostPublicStreamingSetIntensityRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -80,6 +101,7 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/streaming/set-intensity",
                                 baseUri: HttpClient.BaseAddress);
@@ -159,6 +181,8 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -169,6 +193,11 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -186,6 +215,8 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -195,8 +226,7 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -205,6 +235,11 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -221,14 +256,15 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -268,6 +304,8 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -288,6 +326,8 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -384,6 +424,10 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -405,6 +449,10 @@ partial void ProcessPostPublicStreamingSetIntensityResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingSetLoopState.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingSetLoopState.g.cs
index 0010932..17ca0bb 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingSetLoopState.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStreamingSetLoopState.g.cs
@@ -46,6 +46,27 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PostPublicStreamingSetLoopStateAsync(
 
+            global::Mubert.PostPublicStreamingSetLoopStateRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await PostPublicStreamingSetLoopStateAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Set stream loop state<br/>
+        /// Enable or disable loop mode for the current stream segment. When enabled, the later part of the music composition will loop continuously.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicStreamingSetLoopStateAsResponseAsync(
+
             global::Mubert.PostPublicStreamingSetLoopStateRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -80,6 +101,7 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/streaming/set-loop-state",
                                 baseUri: HttpClient.BaseAddress);
@@ -159,6 +181,8 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -169,6 +193,11 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -186,6 +215,8 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -195,8 +226,7 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -205,6 +235,11 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -221,14 +256,15 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -268,6 +304,8 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -288,6 +326,8 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -384,6 +424,10 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -405,6 +449,10 @@ partial void ProcessPostPublicStreamingSetLoopStateResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStripeWebhook.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStripeWebhook.g.cs
index d4f79fc..83b8828 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStripeWebhook.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicStripeWebhook.g.cs
@@ -43,6 +43,21 @@ partial void ProcessPostPublicStripeWebhookResponse(
         public async global::System.Threading.Tasks.Task PostPublicStripeWebhookAsync(
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await PostPublicStripeWebhookAsResponseAsync(
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Stripe webhook endpoint for processing payment events
+        /// </summary>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicStripeWebhookAsResponseAsync(
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -71,6 +86,7 @@ partial void ProcessPostPublicStripeWebhookResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/stripe/webhook",
                                 baseUri: HttpClient.BaseAddress);
@@ -143,6 +159,8 @@ partial void ProcessPostPublicStripeWebhookResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -153,6 +171,11 @@ partial void ProcessPostPublicStripeWebhookResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -170,6 +193,8 @@ partial void ProcessPostPublicStripeWebhookResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -179,8 +204,7 @@ partial void ProcessPostPublicStripeWebhookResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -189,6 +213,11 @@ partial void ProcessPostPublicStripeWebhookResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -205,14 +234,15 @@ partial void ProcessPostPublicStripeWebhookResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -252,6 +282,8 @@ partial void ProcessPostPublicStripeWebhookResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -272,6 +304,8 @@ partial void ProcessPostPublicStripeWebhookResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Invalid payload or signature
@@ -330,6 +364,10 @@ partial void ProcessPostPublicStripeWebhookResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -351,6 +389,10 @@ partial void ProcessPostPublicStripeWebhookResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicSubscriptionsBuy.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicSubscriptionsBuy.g.cs
index aaaade5..f87201e 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicSubscriptionsBuy.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicSubscriptionsBuy.g.cs
@@ -50,6 +50,28 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Mubert.PostPublicSubscriptionsBuyResponse> PostPublicSubscriptionsBuyAsync(
 
+            global::Mubert.PostPublicSubscriptionsBuyRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PostPublicSubscriptionsBuyAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Buy a subscription. Creates a Stripe Checkout session and returns the checkout URL.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicSubscriptionsBuyResponse>> PostPublicSubscriptionsBuyAsResponseAsync(
+
             global::Mubert.PostPublicSubscriptionsBuyRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -84,6 +106,7 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/subscriptions/buy",
                                 baseUri: HttpClient.BaseAddress);
@@ -163,6 +186,8 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -173,6 +198,11 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -190,6 +220,8 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -199,8 +231,7 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -209,6 +240,11 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -225,14 +261,15 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -272,6 +309,8 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -292,6 +331,8 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -420,9 +461,13 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.PostPublicSubscriptionsBuyResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.PostPublicSubscriptionsBuyResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicSubscriptionsBuyResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -450,9 +495,13 @@ partial void ProcessPostPublicSubscriptionsBuyResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.PostPublicSubscriptionsBuyResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.PostPublicSubscriptionsBuyResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicSubscriptionsBuyResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicSubscriptionsCancel.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicSubscriptionsCancel.g.cs
index f4efb62..637b002 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicSubscriptionsCancel.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicSubscriptionsCancel.g.cs
@@ -46,6 +46,27 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PostPublicSubscriptionsCancelAsync(
 
+            global::Mubert.PostPublicSubscriptionsCancelRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await PostPublicSubscriptionsCancelAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Cancel Subscription<br/>
+        /// Cancel a subscription by company ID and license token. Cancels at the end of the current billing period.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostPublicSubscriptionsCancelAsResponseAsync(
+
             global::Mubert.PostPublicSubscriptionsCancelRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -80,6 +101,7 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/subscriptions/cancel",
                                 baseUri: HttpClient.BaseAddress);
@@ -159,6 +181,8 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -169,6 +193,11 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -186,6 +215,8 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -195,8 +226,7 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -205,6 +235,11 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -221,14 +256,15 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -268,6 +304,8 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -288,6 +326,8 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -374,6 +414,10 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -395,6 +439,10 @@ partial void ProcessPostPublicSubscriptionsCancelResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracks.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracks.g.cs
index f3462ae..40718a3 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracks.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracks.g.cs
@@ -51,6 +51,29 @@ partial void ProcessPostPublicTracksResponseContent(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Mubert.PostPublicTracksResponse> PostPublicTracksAsync(
 
+            global::Mubert.PostPublicTracksRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PostPublicTracksAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Create track<br/>
+        /// Create a custom music track from channel/category parameters, text prompt, or image. Supports multiple generation modes: track, loop, jingle, and mix.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksResponse>> PostPublicTracksAsResponseAsync(
+
             global::Mubert.PostPublicTracksRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -85,6 +108,7 @@ partial void ProcessPostPublicTracksResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/tracks",
                                 baseUri: HttpClient.BaseAddress);
@@ -164,6 +188,8 @@ partial void ProcessPostPublicTracksResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -174,6 +200,11 @@ partial void ProcessPostPublicTracksResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -191,6 +222,8 @@ partial void ProcessPostPublicTracksResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -200,8 +233,7 @@ partial void ProcessPostPublicTracksResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -210,6 +242,11 @@ partial void ProcessPostPublicTracksResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -226,14 +263,15 @@ partial void ProcessPostPublicTracksResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -273,6 +311,8 @@ partial void ProcessPostPublicTracksResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -293,6 +333,8 @@ partial void ProcessPostPublicTracksResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -426,9 +468,13 @@ partial void ProcessPostPublicTracksResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.PostPublicTracksResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.PostPublicTracksResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -456,9 +502,13 @@ partial void ProcessPostPublicTracksResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.PostPublicTracksResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.PostPublicTracksResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksByTrackEdit.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksByTrackEdit.g.cs
index 9245aa7..e65f031 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksByTrackEdit.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksByTrackEdit.g.cs
@@ -57,6 +57,34 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
         public async global::System.Threading.Tasks.Task<global::Mubert.PostPublicTracksByTrackEditResponse> PostPublicTracksByTrackEditAsync(
             global::System.Guid track,
 
+            global::Mubert.PostPublicTracksByTrackEditRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PostPublicTracksByTrackEditAsResponseAsync(
+                track: track,
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Edit track<br/>
+        /// Modify track parameters or manipulate instrument/stem composition. Allows changing duration, bitrate, format, intensity, as well as replacing or removing specific instruments and stems.
+        /// </summary>
+        /// <param name="track">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksByTrackEditResponse>> PostPublicTracksByTrackEditAsResponseAsync(
+            global::System.Guid track,
+
             global::Mubert.PostPublicTracksByTrackEditRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -92,6 +120,7 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/public/tracks/{track}/edit",
                                 baseUri: HttpClient.BaseAddress);
@@ -172,6 +201,8 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -182,6 +213,11 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -199,6 +235,8 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -208,8 +246,7 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -218,6 +255,11 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -234,14 +276,15 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -281,6 +324,8 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -301,6 +346,8 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -472,9 +519,13 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.PostPublicTracksByTrackEditResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.PostPublicTracksByTrackEditResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksByTrackEditResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -502,9 +553,13 @@ partial void ProcessPostPublicTracksByTrackEditResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.PostPublicTracksByTrackEditResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.PostPublicTracksByTrackEditResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksByTrackEditResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksByTrackSimilar.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksByTrackSimilar.g.cs
index f3c243d..60c04b6 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksByTrackSimilar.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksByTrackSimilar.g.cs
@@ -57,6 +57,34 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
         public async global::System.Threading.Tasks.Task<global::Mubert.PostPublicTracksByTrackSimilarResponse> PostPublicTracksByTrackSimilarAsync(
             global::System.Guid track,
 
+            global::Mubert.PostPublicTracksByTrackSimilarRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PostPublicTracksByTrackSimilarAsResponseAsync(
+                track: track,
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Generate similar track<br/>
+        /// Generate a new track similar to an existing one. Uses the original track parameters as a base and allows overriding duration, bitrate, format, intensity, and mode.
+        /// </summary>
+        /// <param name="track">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksByTrackSimilarResponse>> PostPublicTracksByTrackSimilarAsResponseAsync(
+            global::System.Guid track,
+
             global::Mubert.PostPublicTracksByTrackSimilarRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -92,6 +120,7 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/public/tracks/{track}/similar",
                                 baseUri: HttpClient.BaseAddress);
@@ -172,6 +201,8 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -182,6 +213,11 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -199,6 +235,8 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -208,8 +246,7 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -218,6 +255,11 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -234,14 +276,15 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -281,6 +324,8 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -301,6 +346,8 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -472,9 +519,13 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.PostPublicTracksByTrackSimilarResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.PostPublicTracksByTrackSimilarResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksByTrackSimilarResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -502,9 +553,13 @@ partial void ProcessPostPublicTracksByTrackSimilarResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.PostPublicTracksByTrackSimilarResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.PostPublicTracksByTrackSimilarResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksByTrackSimilarResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksRecord.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksRecord.g.cs
index 70bf6e6..504c947 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksRecord.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksRecord.g.cs
@@ -51,6 +51,29 @@ partial void ProcessPostPublicTracksRecordResponseContent(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Mubert.PostPublicTracksRecordResponse> PostPublicTracksRecordAsync(
 
+            global::Mubert.PostPublicTracksRecordRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PostPublicTracksRecordAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Record track<br/>
+        /// Record a new track by sending a request directly to the track-recorder service, bypassing the track-store cache.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksRecordResponse>> PostPublicTracksRecordAsResponseAsync(
+
             global::Mubert.PostPublicTracksRecordRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -85,6 +108,7 @@ partial void ProcessPostPublicTracksRecordResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/tracks/record",
                                 baseUri: HttpClient.BaseAddress);
@@ -164,6 +188,8 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -174,6 +200,11 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -191,6 +222,8 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -200,8 +233,7 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -210,6 +242,11 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -226,14 +263,15 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -273,6 +311,8 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -293,6 +333,8 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -426,9 +468,13 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.PostPublicTracksRecordResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.PostPublicTracksRecordResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksRecordResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -456,9 +502,13 @@ partial void ProcessPostPublicTracksRecordResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.PostPublicTracksRecordResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.PostPublicTracksRecordResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksRecordResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksStored.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksStored.g.cs
index 695d558..4327ac0 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksStored.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.PostPublicTracksStored.g.cs
@@ -51,6 +51,29 @@ partial void ProcessPostPublicTracksStoredResponseContent(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Mubert.PostPublicTracksStoredResponse> PostPublicTracksStoredAsync(
 
+            global::Mubert.PostPublicTracksStoredRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PostPublicTracksStoredAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Get stored track<br/>
+        /// Retrieve a pre-generated track from the track-store. Returns a cached track matching the requested parameters if available.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksStoredResponse>> PostPublicTracksStoredAsResponseAsync(
+
             global::Mubert.PostPublicTracksStoredRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -85,6 +108,7 @@ partial void ProcessPostPublicTracksStoredResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/public/tracks/stored",
                                 baseUri: HttpClient.BaseAddress);
@@ -164,6 +188,8 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -174,6 +200,11 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -191,6 +222,8 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -200,8 +233,7 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -210,6 +242,11 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -226,14 +263,15 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -273,6 +311,8 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -293,6 +333,8 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -464,9 +506,13 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.PostPublicTracksStoredResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.PostPublicTracksStoredResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksStoredResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -494,9 +540,13 @@ partial void ProcessPostPublicTracksStoredResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.PostPublicTracksStoredResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.PostPublicTracksStoredResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostPublicTracksStoredResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicClient.g.cs b/src/libs/Mubert/Generated/Mubert.PublicClient.g.cs
index fa89b3c..07188e4 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicClient.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicClient.g.cs
@@ -73,10 +73,10 @@ public PublicClient(
         /// <param name="options">Client-wide request defaults such as headers, query parameters, retries, and timeout.</param>
         /// <param name="disposeHttpClient">Dispose the HttpClient when the instance is disposed. True by default.</param>
         public PublicClient(
-            global::System.Net.Http.HttpClient? httpClient = null,
-            global::System.Uri? baseUri = null,
-            global::System.Collections.Generic.List<global::Mubert.EndPointAuthorization>? authorizations = null,
-            global::Mubert.AutoSDKClientOptions? options = null,
+            global::System.Net.Http.HttpClient? httpClient,
+            global::System.Uri? baseUri,
+            global::System.Collections.Generic.List<global::Mubert.EndPointAuthorization>? authorizations,
+            global::Mubert.AutoSDKClientOptions? options,
             bool disposeHttpClient = true)
         {
 
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.DeleteServiceCustomersByCustomer.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.DeleteServiceCustomersByCustomer.g.cs
index b00560d..3b02b37 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.DeleteServiceCustomersByCustomer.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.DeleteServiceCustomersByCustomer.g.cs
@@ -52,6 +52,32 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
         public async global::System.Threading.Tasks.Task DeleteServiceCustomersByCustomerAsync(
             global::System.Guid customer,
 
+            object request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await DeleteServiceCustomersByCustomerAsResponseAsync(
+                customer: customer,
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Delete customer<br/>
+        /// Remove a customer account by their unique identifier. This action is irreversible.
+        /// </summary>
+        /// <param name="customer">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> DeleteServiceCustomersByCustomerAsResponseAsync(
+            global::System.Guid customer,
+
             object request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -87,6 +113,7 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/service/customers/{customer}",
                                 baseUri: HttpClient.BaseAddress);
@@ -167,6 +194,8 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -177,6 +206,11 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -194,6 +228,8 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -203,8 +239,7 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -213,6 +248,11 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -229,14 +269,15 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -276,6 +317,8 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -296,6 +339,8 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -463,6 +508,10 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -484,6 +533,10 @@ partial void ProcessDeleteServiceCustomersByCustomerResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomers.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomers.g.cs
index 23ef944..9b63ecd 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomers.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomers.g.cs
@@ -61,6 +61,34 @@ partial void ProcessGetServiceCustomersResponseContent(
             int? limit = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetServiceCustomersAsResponseAsync(
+                offset: offset,
+                limit: limit,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Retrieve a list of customers<br/>
+        /// Fetches a list of customers with optional pagination
+        /// </summary>
+        /// <param name="offset">
+        /// Example: 0
+        /// </param>
+        /// <param name="limit">
+        /// Example: 25
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceCustomersResponse>> GetServiceCustomersAsResponseAsync(
+            int? offset = default,
+            int? limit = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -91,12 +119,13 @@ partial void ProcessGetServiceCustomersResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/service/customers",
-                                baseUri: HttpClient.BaseAddress); 
+                                baseUri: HttpClient.BaseAddress);
                             __pathBuilder
                                 .AddOptionalParameter("offset", offset?.ToString())
-                                .AddOptionalParameter("limit", limit?.ToString()) 
+                                .AddOptionalParameter("limit", limit?.ToString())
                                 ;
                             var __path = __pathBuilder.ToString();
                 __path = global::Mubert.AutoSDKRequestOptionsSupport.AppendQueryParameters(
@@ -169,6 +198,8 @@ partial void ProcessGetServiceCustomersResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -179,6 +210,11 @@ partial void ProcessGetServiceCustomersResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -196,6 +232,8 @@ partial void ProcessGetServiceCustomersResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -205,8 +243,7 @@ partial void ProcessGetServiceCustomersResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -215,6 +252,11 @@ partial void ProcessGetServiceCustomersResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -231,14 +273,15 @@ partial void ProcessGetServiceCustomersResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -278,6 +321,8 @@ partial void ProcessGetServiceCustomersResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -298,6 +343,8 @@ partial void ProcessGetServiceCustomersResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -431,9 +478,13 @@ partial void ProcessGetServiceCustomersResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetServiceCustomersResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetServiceCustomersResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceCustomersResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -461,9 +512,13 @@ partial void ProcessGetServiceCustomersResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetServiceCustomersResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetServiceCustomersResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceCustomersResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomersByCustomer.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomersByCustomer.g.cs
index ecceb7a..6c3ebea 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomersByCustomer.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomersByCustomer.g.cs
@@ -55,6 +55,29 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
             global::System.Guid customer,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetServiceCustomersByCustomerAsResponseAsync(
+                customer: customer,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Retrieve customer details by ID<br/>
+        /// Fetches the details of a specific customer using their unique identifier
+        /// </summary>
+        /// <param name="customer">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>> GetServiceCustomersByCustomerAsResponseAsync(
+            global::System.Guid customer,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -84,6 +107,7 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/service/customers/{customer}",
                                 baseUri: HttpClient.BaseAddress);
@@ -157,6 +181,8 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -167,6 +193,11 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -184,6 +215,8 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -193,8 +226,7 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -203,6 +235,11 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -219,14 +256,15 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -266,6 +304,8 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -286,6 +326,8 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -457,9 +499,13 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.CustomerServiceResource.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.CustomerServiceResource.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -487,9 +533,13 @@ partial void ProcessGetServiceCustomersByCustomerResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.CustomerServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.CustomerServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomersCustomIdByCustomid.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomersCustomIdByCustomid.g.cs
index f987ccb..6149c71 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomersCustomIdByCustomid.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceCustomersCustomIdByCustomid.g.cs
@@ -55,6 +55,29 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
             global::System.Guid customId,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetServiceCustomersCustomIdByCustomidAsResponseAsync(
+                customId: customId,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Retrieve customer by custom ID<br/>
+        /// Fetches the details of a customer based on their custom ID
+        /// </summary>
+        /// <param name="customId">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>> GetServiceCustomersCustomIdByCustomidAsResponseAsync(
+            global::System.Guid customId,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -84,6 +107,7 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/service/customers/custom-id/{customId}",
                                 baseUri: HttpClient.BaseAddress);
@@ -157,6 +181,8 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -167,6 +193,11 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -184,6 +215,8 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -193,8 +226,7 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -203,6 +235,11 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -219,14 +256,15 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -266,6 +304,8 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -286,6 +326,8 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -457,9 +499,13 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.CustomerServiceResource.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.CustomerServiceResource.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -487,9 +533,13 @@ partial void ProcessGetServiceCustomersCustomIdByCustomidResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.CustomerServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.CustomerServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceLicenses.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceLicenses.g.cs
index 36d7ab0..57a9108 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceLicenses.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceLicenses.g.cs
@@ -61,6 +61,34 @@ partial void ProcessGetServiceLicensesResponseContent(
             int? limit = default,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetServiceLicensesAsResponseAsync(
+                offset: offset,
+                limit: limit,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Retrieve a list of licenses<br/>
+        /// Retrieve a paginated list of all licenses for the company, including features, bitrates, formats, modes, and limits.
+        /// </summary>
+        /// <param name="offset">
+        /// Example: 0
+        /// </param>
+        /// <param name="limit">
+        /// Example: 25
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceLicensesResponse>> GetServiceLicensesAsResponseAsync(
+            int? offset = default,
+            int? limit = default,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -91,12 +119,13 @@ partial void ProcessGetServiceLicensesResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/service/licenses",
-                                baseUri: HttpClient.BaseAddress); 
+                                baseUri: HttpClient.BaseAddress);
                             __pathBuilder
                                 .AddOptionalParameter("offset", offset?.ToString())
-                                .AddOptionalParameter("limit", limit?.ToString()) 
+                                .AddOptionalParameter("limit", limit?.ToString())
                                 ;
                             var __path = __pathBuilder.ToString();
                 __path = global::Mubert.AutoSDKRequestOptionsSupport.AppendQueryParameters(
@@ -169,6 +198,8 @@ partial void ProcessGetServiceLicensesResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -179,6 +210,11 @@ partial void ProcessGetServiceLicensesResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -196,6 +232,8 @@ partial void ProcessGetServiceLicensesResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -205,8 +243,7 @@ partial void ProcessGetServiceLicensesResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -215,6 +252,11 @@ partial void ProcessGetServiceLicensesResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -231,14 +273,15 @@ partial void ProcessGetServiceLicensesResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -278,6 +321,8 @@ partial void ProcessGetServiceLicensesResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -298,6 +343,8 @@ partial void ProcessGetServiceLicensesResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -431,9 +478,13 @@ partial void ProcessGetServiceLicensesResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetServiceLicensesResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetServiceLicensesResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceLicensesResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -461,9 +512,13 @@ partial void ProcessGetServiceLicensesResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetServiceLicensesResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetServiceLicensesResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceLicensesResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceLicensesByLicense.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceLicensesByLicense.g.cs
index 6f0a0eb..e4b994e 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceLicensesByLicense.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.GetServiceLicensesByLicense.g.cs
@@ -55,6 +55,29 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
             global::System.Guid license,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetServiceLicensesByLicenseAsResponseAsync(
+                license: license,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Retrieve details of a specific license<br/>
+        /// Retrieve details for a specific license including type, status, webhook configuration, track expiration time, feature access, and comprehensive limits.
+        /// </summary>
+        /// <param name="license">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.LicenseServiceResource>> GetServiceLicensesByLicenseAsResponseAsync(
+            global::System.Guid license,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
                 client: HttpClient);
@@ -84,6 +107,7 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/service/licenses/{license}",
                                 baseUri: HttpClient.BaseAddress);
@@ -157,6 +181,8 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -167,6 +193,11 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -184,6 +215,8 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -193,8 +226,7 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -203,6 +235,11 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -219,14 +256,15 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -266,6 +304,8 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -286,6 +326,8 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -457,9 +499,13 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.LicenseServiceResource.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.LicenseServiceResource.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.LicenseServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -487,9 +533,13 @@ partial void ProcessGetServiceLicensesByLicenseResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.LicenseServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.LicenseServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.LicenseServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PostServiceCustomers.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PostServiceCustomers.g.cs
index 33f6a50..2baf87d 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PostServiceCustomers.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PostServiceCustomers.g.cs
@@ -51,6 +51,29 @@ partial void ProcessPostServiceCustomersResponseContent(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Mubert.CustomerServiceResource> PostServiceCustomersAsync(
 
+            global::Mubert.PostServiceCustomersRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PostServiceCustomersAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Create a new customer<br/>
+        /// Create a new customer account. Requires a unique custom_id (alphanumeric, max 255 chars). Returns customer_id and access_token for public API authentication.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>> PostServiceCustomersAsResponseAsync(
+
             global::Mubert.PostServiceCustomersRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -85,6 +108,7 @@ partial void ProcessPostServiceCustomersResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/service/customers",
                                 baseUri: HttpClient.BaseAddress);
@@ -164,6 +188,8 @@ partial void ProcessPostServiceCustomersResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -174,6 +200,11 @@ partial void ProcessPostServiceCustomersResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -191,6 +222,8 @@ partial void ProcessPostServiceCustomersResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -200,8 +233,7 @@ partial void ProcessPostServiceCustomersResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -210,6 +242,11 @@ partial void ProcessPostServiceCustomersResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -226,14 +263,15 @@ partial void ProcessPostServiceCustomersResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -273,6 +311,8 @@ partial void ProcessPostServiceCustomersResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -293,6 +333,8 @@ partial void ProcessPostServiceCustomersResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -426,9 +468,13 @@ partial void ProcessPostServiceCustomersResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.CustomerServiceResource.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.CustomerServiceResource.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -456,9 +502,13 @@ partial void ProcessPostServiceCustomersResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.CustomerServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.CustomerServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PutServiceCustomersByCustomer.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PutServiceCustomersByCustomer.g.cs
index b185665..d33e024 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PutServiceCustomersByCustomer.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PutServiceCustomersByCustomer.g.cs
@@ -57,6 +57,34 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
         public async global::System.Threading.Tasks.Task<global::Mubert.CustomerServiceResource> PutServiceCustomersByCustomerAsync(
             global::System.Guid customer,
 
+            global::Mubert.PutServiceCustomersByCustomerRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PutServiceCustomersByCustomerAsResponseAsync(
+                customer: customer,
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Update an existing customer<br/>
+        /// Handles the update of an existing customer identified by their UUID
+        /// </summary>
+        /// <param name="customer">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>> PutServiceCustomersByCustomerAsResponseAsync(
+            global::System.Guid customer,
+
             global::Mubert.PutServiceCustomersByCustomerRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -92,6 +120,7 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/service/customers/{customer}",
                                 baseUri: HttpClient.BaseAddress);
@@ -172,6 +201,8 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -182,6 +213,11 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -199,6 +235,8 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -208,8 +246,7 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -218,6 +255,11 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -234,14 +276,15 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -281,6 +324,8 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -301,6 +346,8 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // Unauthenticated - the user is not authenticated to access this resource
@@ -472,9 +519,13 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.CustomerServiceResource.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.CustomerServiceResource.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -502,9 +553,13 @@ partial void ProcessPutServiceCustomersByCustomerResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.CustomerServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.CustomerServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.CustomerServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PutServiceLicensesByLicense.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PutServiceLicensesByLicense.g.cs
index 3647beb..fa8d1ac 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PutServiceLicensesByLicense.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.PutServiceLicensesByLicense.g.cs
@@ -57,6 +57,34 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
         public async global::System.Threading.Tasks.Task<global::Mubert.LicenseServiceResource> PutServiceLicensesByLicenseAsync(
             global::System.Guid license,
 
+            global::Mubert.PutServiceLicensesByLicenseRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PutServiceLicensesByLicenseAsResponseAsync(
+                license: license,
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Update license<br/>
+        /// Update license parameters such as webhook URL and webhook enabled state. Webhooks receive track models when generation completes.
+        /// </summary>
+        /// <param name="license">
+        /// Example: 123e4567-e89b-12d3-a456-426614174000
+        /// </param>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.LicenseServiceResource>> PutServiceLicensesByLicenseAsResponseAsync(
+            global::System.Guid license,
+
             global::Mubert.PutServiceLicensesByLicenseRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -92,6 +120,7 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: $"/api/v3/service/licenses/{license}",
                                 baseUri: HttpClient.BaseAddress);
@@ -172,6 +201,8 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -182,6 +213,11 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -199,6 +235,8 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -208,8 +246,7 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -218,6 +255,11 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -234,14 +276,15 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -281,6 +324,8 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -301,6 +346,8 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -434,9 +481,13 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.LicenseServiceResource.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.LicenseServiceResource.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.LicenseServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -464,9 +515,13 @@ partial void ProcessPutServiceLicensesByLicenseResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.LicenseServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.LicenseServiceResource.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.LicenseServiceResource>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.g.cs b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.g.cs
index 99e16e1..fceaa17 100644
--- a/src/libs/Mubert/Generated/Mubert.PublicServiceClient.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.PublicServiceClient.g.cs
@@ -73,10 +73,10 @@ public PublicServiceClient(
         /// <param name="options">Client-wide request defaults such as headers, query parameters, retries, and timeout.</param>
         /// <param name="disposeHttpClient">Dispose the HttpClient when the instance is disposed. True by default.</param>
         public PublicServiceClient(
-            global::System.Net.Http.HttpClient? httpClient = null,
-            global::System.Uri? baseUri = null,
-            global::System.Collections.Generic.List<global::Mubert.EndPointAuthorization>? authorizations = null,
-            global::Mubert.AutoSDKClientOptions? options = null,
+            global::System.Net.Http.HttpClient? httpClient,
+            global::System.Uri? baseUri,
+            global::System.Collections.Generic.List<global::Mubert.EndPointAuthorization>? authorizations,
+            global::Mubert.AutoSDKClientOptions? options,
             bool disposeHttpClient = true)
         {
 
diff --git a/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeBillingPortal.g.cs b/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeBillingPortal.g.cs
index d2a45b1..b07e05a 100644
--- a/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeBillingPortal.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeBillingPortal.g.cs
@@ -51,6 +51,29 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Mubert.GetServiceStripeBillingPortalResponse> GetServiceStripeBillingPortalAsync(
 
+            global::Mubert.GetServiceStripeBillingPortalRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetServiceStripeBillingPortalAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Stripe Billing Portal (GET)<br/>
+        /// Create a Stripe billing portal session by company ID and license token.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceStripeBillingPortalResponse>> GetServiceStripeBillingPortalAsResponseAsync(
+
             global::Mubert.GetServiceStripeBillingPortalRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -85,6 +108,7 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/service/stripe/billing-portal",
                                 baseUri: HttpClient.BaseAddress);
@@ -164,6 +188,8 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -174,6 +200,11 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -191,6 +222,8 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -200,8 +233,7 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -210,6 +242,11 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -226,14 +263,15 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -273,6 +311,8 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -293,6 +333,8 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -383,9 +425,13 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetServiceStripeBillingPortalResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetServiceStripeBillingPortalResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceStripeBillingPortalResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -413,9 +459,13 @@ partial void ProcessGetServiceStripeBillingPortalResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetServiceStripeBillingPortalResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetServiceStripeBillingPortalResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceStripeBillingPortalResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeSubscriptionsBuy.g.cs b/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeSubscriptionsBuy.g.cs
index d80264c..c7ca2f9 100644
--- a/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeSubscriptionsBuy.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeSubscriptionsBuy.g.cs
@@ -50,6 +50,28 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Mubert.GetServiceStripeSubscriptionsBuyResponse> GetServiceStripeSubscriptionsBuyAsync(
 
+            global::Mubert.GetServiceStripeSubscriptionsBuyRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await GetServiceStripeSubscriptionsBuyAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Buy a subscription via GET (redirect flow). Creates a Stripe Checkout session and redirects to checkout URL.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceStripeSubscriptionsBuyResponse>> GetServiceStripeSubscriptionsBuyAsResponseAsync(
+
             global::Mubert.GetServiceStripeSubscriptionsBuyRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -84,6 +106,7 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/service/stripe/subscriptions/buy",
                                 baseUri: HttpClient.BaseAddress);
@@ -163,6 +186,8 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -173,6 +198,11 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -190,6 +220,8 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -199,8 +231,7 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -209,6 +240,11 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -225,14 +261,15 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -272,6 +309,8 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -292,6 +331,8 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -420,9 +461,13 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.GetServiceStripeSubscriptionsBuyResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.GetServiceStripeSubscriptionsBuyResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceStripeSubscriptionsBuyResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -450,9 +495,13 @@ partial void ProcessGetServiceStripeSubscriptionsBuyResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.GetServiceStripeSubscriptionsBuyResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.GetServiceStripeSubscriptionsBuyResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.GetServiceStripeSubscriptionsBuyResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeSubscriptionsCancel.g.cs b/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeSubscriptionsCancel.g.cs
index e02dffa..2a761a2 100644
--- a/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeSubscriptionsCancel.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.ServiceClient.GetServiceStripeSubscriptionsCancel.g.cs
@@ -46,6 +46,27 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task GetServiceStripeSubscriptionsCancelAsync(
 
+            global::Mubert.GetServiceStripeSubscriptionsCancelRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await GetServiceStripeSubscriptionsCancelAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Cancel Subscription (GET)<br/>
+        /// Cancel a subscription via GET. Cancels at the end of the current billing period.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> GetServiceStripeSubscriptionsCancelAsResponseAsync(
+
             global::Mubert.GetServiceStripeSubscriptionsCancelRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -80,6 +101,7 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/service/stripe/subscriptions/cancel",
                                 baseUri: HttpClient.BaseAddress);
@@ -159,6 +181,8 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -169,6 +193,11 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -186,6 +215,8 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -195,8 +226,7 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -205,6 +235,11 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -221,14 +256,15 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -268,6 +304,8 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -288,6 +326,8 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -374,6 +414,10 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -395,6 +439,10 @@ partial void ProcessGetServiceStripeSubscriptionsCancelResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeBillingPortal.g.cs b/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeBillingPortal.g.cs
index f494b42..aa47718 100644
--- a/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeBillingPortal.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeBillingPortal.g.cs
@@ -46,6 +46,27 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PostServiceStripeBillingPortalAsync(
 
+            global::Mubert.PostServiceStripeBillingPortalRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await PostServiceStripeBillingPortalAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Stripe Billing Portal<br/>
+        /// Create a Stripe billing portal session by company ID and license token.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostServiceStripeBillingPortalAsResponseAsync(
+
             global::Mubert.PostServiceStripeBillingPortalRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -80,6 +101,7 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/service/stripe/billing-portal",
                                 baseUri: HttpClient.BaseAddress);
@@ -159,6 +181,8 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -169,6 +193,11 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -186,6 +215,8 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -195,8 +226,7 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -205,6 +235,11 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -221,14 +256,15 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -268,6 +304,8 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -288,6 +326,8 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -374,6 +414,10 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -395,6 +439,10 @@ partial void ProcessPostServiceStripeBillingPortalResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeSubscriptionsBuy.g.cs b/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeSubscriptionsBuy.g.cs
index f3b6664..25bd03e 100644
--- a/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeSubscriptionsBuy.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeSubscriptionsBuy.g.cs
@@ -50,6 +50,28 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Mubert.PostServiceStripeSubscriptionsBuyResponse> PostServiceStripeSubscriptionsBuyAsync(
 
+            global::Mubert.PostServiceStripeSubscriptionsBuyRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            var __response = await PostServiceStripeSubscriptionsBuyAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+
+            return __response.Body;
+        }
+        /// <summary>
+        /// Buy a subscription. Creates a Stripe Checkout session and returns the checkout URL.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse<global::Mubert.PostServiceStripeSubscriptionsBuyResponse>> PostServiceStripeSubscriptionsBuyAsResponseAsync(
+
             global::Mubert.PostServiceStripeSubscriptionsBuyRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -84,6 +106,7 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/service/stripe/subscriptions/buy",
                                 baseUri: HttpClient.BaseAddress);
@@ -163,6 +186,8 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -173,6 +198,11 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -190,6 +220,8 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -199,8 +231,7 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -209,6 +240,11 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -225,14 +261,15 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -272,6 +309,8 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -292,6 +331,8 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -420,9 +461,13 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
-                                    return
-                                        global::Mubert.PostServiceStripeSubscriptionsBuyResponse.FromJson(__content, JsonSerializerContext) ??
+                                    var __value = global::Mubert.PostServiceStripeSubscriptionsBuyResponse.FromJson(__content, JsonSerializerContext) ??
                                         throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostServiceStripeSubscriptionsBuyResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -450,9 +495,13 @@ partial void ProcessPostServiceStripeSubscriptionsBuyResponseContent(
                 #endif
                                     ).ConfigureAwait(false);
 
-                                    return
-                                        await global::Mubert.PostServiceStripeSubscriptionsBuyResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                    var __value = await global::Mubert.PostServiceStripeSubscriptionsBuyResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
                                         throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                    return new global::Mubert.AutoSDKHttpResponse<global::Mubert.PostServiceStripeSubscriptionsBuyResponse>(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri,
+                                        body: __value);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeSubscriptionsCancel.g.cs b/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeSubscriptionsCancel.g.cs
index 0557aaa..a20d2a9 100644
--- a/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeSubscriptionsCancel.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.ServiceClient.PostServiceStripeSubscriptionsCancel.g.cs
@@ -46,6 +46,27 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
         /// <exception cref="global::Mubert.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PostServiceStripeSubscriptionsCancelAsync(
 
+            global::Mubert.PostServiceStripeSubscriptionsCancelRequest request,
+            global::Mubert.AutoSDKRequestOptions? requestOptions = default,
+            global::System.Threading.CancellationToken cancellationToken = default)
+        {
+            await PostServiceStripeSubscriptionsCancelAsResponseAsync(
+
+                request: request,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken
+            ).ConfigureAwait(false);
+        }
+        /// <summary>
+        /// Cancel Subscription<br/>
+        /// Cancel a subscription by company ID and license token. Cancels at the end of the current billing period.
+        /// </summary>
+        /// <param name="request"></param>
+        /// <param name="requestOptions">Per-request overrides such as headers, query parameters, timeout, retries, and response buffering.</param>
+        /// <param name="cancellationToken">The token to cancel the operation with</param>
+        /// <exception cref="global::Mubert.ApiException"></exception>
+        public async global::System.Threading.Tasks.Task<global::Mubert.AutoSDKHttpResponse> PostServiceStripeSubscriptionsCancelAsResponseAsync(
+
             global::Mubert.PostServiceStripeSubscriptionsCancelRequest request,
             global::Mubert.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
@@ -80,6 +101,7 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
 
             global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
             {
+
                             var __pathBuilder = new global::Mubert.PathBuilder(
                                 path: "/api/v3/service/stripe/subscriptions/cancel",
                                 baseUri: HttpClient.BaseAddress);
@@ -159,6 +181,8 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                     try
                     {
@@ -169,6 +193,11 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                     }
                     catch (global::System.Net.Http.HttpRequestException __exception)
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: null,
+                            attempt: __attempt);
                         var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
@@ -186,6 +215,8 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: __willRetry,
+                                retryDelay: __willRetry ? __retryDelay : (global::System.TimeSpan?)null,
+                                retryReason: "exception",
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         if (!__willRetry)
                         {
@@ -195,8 +226,7 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -205,6 +235,11 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                         __attempt < __maxAttempts &&
                         global::Mubert.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
+                        var __retryDelay = global::Mubert.AutoSDKRequestOptionsSupport.GetRetryDelay(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            response: __response,
+                            attempt: __attempt);
                         await global::Mubert.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
                             clientOptions: Options,
                             context: global::Mubert.AutoSDKRequestOptionsSupport.CreateHookContext(
@@ -221,14 +256,15 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attempt,
                                 maxAttempts: __maxAttempts,
                                 willRetry: true,
+                                retryDelay: __retryDelay,
+                                retryReason: "status:" + ((int)__response.StatusCode).ToString(global::System.Globalization.CultureInfo.InvariantCulture),
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                         __response.Dispose();
                         __response = null;
                         __httpRequest.Dispose();
                         __httpRequest = null;
                         await global::Mubert.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
-                            clientOptions: Options,
-                            requestOptions: requestOptions,
+                            retryDelay: __retryDelay,
                             cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                         continue;
                     }
@@ -268,6 +304,8 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                 else
@@ -288,6 +326,8 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                                 attempt: __attemptNumber,
                                 maxAttempts: __maxAttempts,
                                 willRetry: false,
+                                retryDelay: null,
+                                retryReason: global::System.String.Empty,
                                 cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
                             // 
@@ -374,6 +414,10 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                                 {
                                     __response.EnsureSuccessStatusCode();
 
+                return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
@@ -395,6 +439,10 @@ partial void ProcessPostServiceStripeSubscriptionsCancelResponse(
                                 try
                                 {
                                     __response.EnsureSuccessStatusCode();
+                                    return new global::Mubert.AutoSDKHttpResponse(
+                                        statusCode: __response.StatusCode,
+                                        headers: global::Mubert.AutoSDKHttpResponse.CreateHeaders(__response),
+                                        requestUri: __response.RequestMessage?.RequestUri);
                                 }
                                 catch (global::System.Exception __ex)
                                 {
diff --git a/src/libs/Mubert/Generated/Mubert.ServiceClient.g.cs b/src/libs/Mubert/Generated/Mubert.ServiceClient.g.cs
index 45e61a8..5b5ea46 100644
--- a/src/libs/Mubert/Generated/Mubert.ServiceClient.g.cs
+++ b/src/libs/Mubert/Generated/Mubert.ServiceClient.g.cs
@@ -73,10 +73,10 @@ public ServiceClient(
         /// <param name="options">Client-wide request defaults such as headers, query parameters, retries, and timeout.</param>
         /// <param name="disposeHttpClient">Dispose the HttpClient when the instance is disposed. True by default.</param>
         public ServiceClient(
-            global::System.Net.Http.HttpClient? httpClient = null,
-            global::System.Uri? baseUri = null,
-            global::System.Collections.Generic.List<global::Mubert.EndPointAuthorization>? authorizations = null,
-            global::Mubert.AutoSDKClientOptions? options = null,
+            global::System.Net.Http.HttpClient? httpClient,
+            global::System.Uri? baseUri,
+            global::System.Collections.Generic.List<global::Mubert.EndPointAuthorization>? authorizations,
+            global::Mubert.AutoSDKClientOptions? options,
             bool disposeHttpClient = true)
         {