From f0c717622d9d838dc1863d3224eebf1375c45c50 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <dependabot@bot.com>
Date: Fri, 10 Apr 2026 02:32:44 +0000
Subject: [PATCH] feat: Updated OpenAPI spec

---
 ...lient.CreateByDatabaseIdItemsByItemId.g.cs |   2 +
 ...iesClient.CreateByDatabaseIdMoreItems.g.cs |   4 +
 ...tabaseIdItemsPropertiesByPropertyName.g.cs |   2 +
 ...esClient.GetByDatabaseIdItemsByItemId.g.cs |   2 +
 ...tabaseIdItemsPropertiesByPropertyName.g.cs |   2 +
 ...nt.GetByDatabaseIdItemsPropertiesList.g.cs |   2 +
 ...tabaseIdItemsPropertiesByPropertyName.g.cs |   2 +
 .../Recombee.IItemPropertiesClient.g.cs       |   5 +
 ...lient.DeleteByDatabaseIdItemsByItemId.g.cs |   2 +
 ...emsClient.DeleteByDatabaseIdMoreItems.g.cs |   4 +
 ...IItemsClient.GetByDatabaseIdItemsList.g.cs |   2 +
 ...msClient.PutByDatabaseIdItemsByItemId.g.cs |   2 +
 .../Generated/Recombee.IItemsClient.g.cs      |   5 +
 ...laneousClient.CreateByDatabaseIdBatch.g.cs |   4 +
 ...iscellaneousClient.DeleteByDatabaseId.g.cs |   2 +
 ...aneousClient.GetByDatabaseIdScenarios.g.cs |   2 +
 .../Recombee.IMiscellaneousClient.g.cs        |   5 +
 .../Generated/Recombee.IRecombeeClient.g.cs   |   5 +
 ...nt.CreateByDatabaseIdRecommsComposite.g.cs |   4 +
 ...baseIdRecommsItemSegmentsItemSegments.g.cs |   4 +
 ...eByDatabaseIdRecommsItemSegmentsItems.g.cs |   4 +
 ...aseIdRecommsItemsByItemIdItemSegments.g.cs |   4 +
 ...ByDatabaseIdRecommsItemsByItemIdItems.g.cs |   4 +
 ...ByDatabaseIdRecommsItemsByItemIdUsers.g.cs |   4 +
 ...yDatabaseIdRecommsNextItemsByRecommId.g.cs |   4 +
 ...aseIdRecommsUsersByUserIdItemSegments.g.cs |   4 +
 ...ByDatabaseIdRecommsUsersByUserIdItems.g.cs |   4 +
 ...ByDatabaseIdRecommsUsersByUserIdUsers.g.cs |   4 +
 .../Recombee.IRecommendationsClient.g.cs      |   5 +
 ...baseIdSearchUsersByUserIdItemSegments.g.cs |   4 +
 ...eByDatabaseIdSearchUsersByUserIdItems.g.cs |   4 +
 ...lient.CreateByDatabaseIdSynonymsItems.g.cs |   4 +
 ...lient.DeleteByDatabaseIdSynonymsItems.g.cs |   2 +
 ...t.DeleteByDatabaseIdSynonymsItemsById.g.cs |   2 +
 ...chClient.GetByDatabaseIdSynonymsItems.g.cs |   2 +
 .../Generated/Recombee.ISearchClient.g.cs     |   5 +
 ...SegmentationsAutoReqlBySegmentationId.g.cs |   4 +
 ...gmentationsManualReqlBySegmentationId.g.cs |   4 +
 ...qlBySegmentationIdSegmentsBySegmentId.g.cs |   4 +
 ...ntationsPropertyBasedBySegmentationId.g.cs |   4 +
 ...tabaseIdSegmentationsBySegmentationId.g.cs |   2 +
 ...qlBySegmentationIdSegmentsBySegmentId.g.cs |   2 +
 ...ient.GetByDatabaseIdSegmentationsList.g.cs |   2 +
 ...seIdSegmentationsListBySegmentationId.g.cs |   2 +
 ...SegmentationsAutoReqlBySegmentationId.g.cs |   4 +
 ...gmentationsManualReqlBySegmentationId.g.cs |   4 +
 ...qlBySegmentationIdSegmentsBySegmentId.g.cs |   4 +
 ...ntationsPropertyBasedBySegmentationId.g.cs |   4 +
 ...combee.ISegmentationsDefinitionClient.g.cs |   5 +
 ...eateByDatabaseIdSeriesBySeriesIdItems.g.cs |   4 +
 ...nt.DeleteByDatabaseIdSeriesBySeriesId.g.cs |   4 +
 ...leteByDatabaseIdSeriesBySeriesIdItems.g.cs |   4 +
 ....GetByDatabaseIdSeriesBySeriesIdItems.g.cs |   2 +
 ...eriesClient.GetByDatabaseIdSeriesList.g.cs |   2 +
 ...lient.PutByDatabaseIdSeriesBySeriesId.g.cs |   4 +
 .../Generated/Recombee.ISeriesClient.g.cs     |   5 +
 ...onsClient.CreateByDatabaseIdBookmarks.g.cs |   4 +
 ...lient.CreateByDatabaseIdCartadditions.g.cs |   4 +
 ...sClient.CreateByDatabaseIdDetailviews.g.cs |   4 +
 ...onsClient.CreateByDatabaseIdPurchases.g.cs |   4 +
 ...tionsClient.CreateByDatabaseIdRatings.g.cs |   4 +
 ...Client.CreateByDatabaseIdViewportions.g.cs |   4 +
 ...onsClient.DeleteByDatabaseIdBookmarks.g.cs |   2 +
 ...lient.DeleteByDatabaseIdCartadditions.g.cs |   2 +
 ...sClient.DeleteByDatabaseIdDetailviews.g.cs |   2 +
 ...onsClient.DeleteByDatabaseIdPurchases.g.cs |   2 +
 ...tionsClient.DeleteByDatabaseIdRatings.g.cs |   2 +
 ...Client.DeleteByDatabaseIdViewportions.g.cs |   2 +
 ...GetByDatabaseIdItemsByItemIdBookmarks.g.cs |   2 +
 ...yDatabaseIdItemsByItemIdCartadditions.g.cs |   2 +
 ...tByDatabaseIdItemsByItemIdDetailviews.g.cs |   2 +
 ...GetByDatabaseIdItemsByItemIdPurchases.g.cs |   2 +
 ...t.GetByDatabaseIdItemsByItemIdRatings.g.cs |   2 +
 ...ByDatabaseIdItemsByItemIdViewportions.g.cs |   2 +
 ...GetByDatabaseIdUsersByUserIdBookmarks.g.cs |   2 +
 ...yDatabaseIdUsersByUserIdCartadditions.g.cs |   2 +
 ...tByDatabaseIdUsersByUserIdDetailviews.g.cs |   2 +
 ...GetByDatabaseIdUsersByUserIdPurchases.g.cs |   2 +
 ...t.GetByDatabaseIdUsersByUserIdRatings.g.cs |   2 +
 ...ByDatabaseIdUsersByUserIdViewportions.g.cs |   2 +
 .../Recombee.IUserItemInteractionsClient.g.cs |   5 +
 ...lient.CreateByDatabaseIdUsersByUserId.g.cs |   2 +
 ...tabaseIdUsersPropertiesByPropertyName.g.cs |   2 +
 ...esClient.GetByDatabaseIdUsersByUserId.g.cs |   2 +
 ...tabaseIdUsersPropertiesByPropertyName.g.cs |   2 +
 ...nt.GetByDatabaseIdUsersPropertiesList.g.cs |   2 +
 ...tabaseIdUsersPropertiesByPropertyName.g.cs |   2 +
 .../Recombee.IUserPropertiesClient.g.cs       |   5 +
 ...lient.DeleteByDatabaseIdUsersByUserId.g.cs |   2 +
 ...IUsersClient.GetByDatabaseIdUsersList.g.cs |   2 +
 ...sersByTargetUserIdMergeBySourceUserId.g.cs |   2 +
 ...rsClient.PutByDatabaseIdUsersByUserId.g.cs |   2 +
 .../Generated/Recombee.IUsersClient.g.cs      |   5 +
 ...lient.CreateByDatabaseIdItemsByItemId.g.cs | 483 +++++++++++-----
 ...iesClient.CreateByDatabaseIdMoreItems.g.cs | 508 +++++++++++------
 ...tabaseIdItemsPropertiesByPropertyName.g.cs | 461 ++++++++++-----
 ...esClient.GetByDatabaseIdItemsByItemId.g.cs | 483 +++++++++++-----
 ...tabaseIdItemsPropertiesByPropertyName.g.cs | 491 +++++++++++-----
 ...nt.GetByDatabaseIdItemsPropertiesList.g.cs | 429 ++++++++++----
 ...tabaseIdItemsPropertiesByPropertyName.g.cs | 469 ++++++++++-----
 .../Recombee.ItemPropertiesClient.g.cs        |  29 +
 ...lient.DeleteByDatabaseIdItemsByItemId.g.cs | 461 ++++++++++-----
 ...emsClient.DeleteByDatabaseIdMoreItems.g.cs | 446 ++++++++++-----
 ....ItemsClient.GetByDatabaseIdItemsList.g.cs | 453 ++++++++++-----
 ...msClient.PutByDatabaseIdItemsByItemId.g.cs | 461 ++++++++++-----
 .../Generated/Recombee.ItemsClient.g.cs       |  29 +
 ...laneousClient.CreateByDatabaseIdBatch.g.cs | 536 +++++++++++------
 ...iscellaneousClient.DeleteByDatabaseId.g.cs | 347 ++++++++---
 ...aneousClient.GetByDatabaseIdScenarios.g.cs | 379 ++++++++----
 .../Recombee.MiscellaneousClient.g.cs         |  29 +
 .../Generated/Recombee.OptionsSupport.g.cs    | 460 +++++++++++++++
 .../Generated/Recombee.PathBuilder.g.cs       |   5 +
 ....RecombeeClient.Authorizations.Bearer.g.cs |   1 +
 .../Generated/Recombee.RecombeeClient.g.cs    |  49 +-
 ...nt.CreateByDatabaseIdRecommsComposite.g.cs | 508 +++++++++++------
 ...baseIdRecommsItemSegmentsItemSegments.g.cs | 508 +++++++++++------
 ...eByDatabaseIdRecommsItemSegmentsItems.g.cs | 508 +++++++++++------
 ...aseIdRecommsItemsByItemIdItemSegments.g.cs | 510 +++++++++++------
 ...ByDatabaseIdRecommsItemsByItemIdItems.g.cs | 510 +++++++++++------
 ...ByDatabaseIdRecommsItemsByItemIdUsers.g.cs | 510 +++++++++++------
 ...yDatabaseIdRecommsNextItemsByRecommId.g.cs | 510 +++++++++++------
 ...aseIdRecommsUsersByUserIdItemSegments.g.cs | 510 +++++++++++------
 ...ByDatabaseIdRecommsUsersByUserIdItems.g.cs | 510 +++++++++++------
 ...ByDatabaseIdRecommsUsersByUserIdUsers.g.cs | 510 +++++++++++------
 .../Recombee.RecommendationsClient.g.cs       |  29 +
 ...baseIdSearchUsersByUserIdItemSegments.g.cs | 510 +++++++++++------
 ...eByDatabaseIdSearchUsersByUserIdItems.g.cs | 510 +++++++++++------
 ...lient.CreateByDatabaseIdSynonymsItems.g.cs | 508 +++++++++++------
 ...lient.DeleteByDatabaseIdSynonymsItems.g.cs | 347 ++++++++---
 ...t.DeleteByDatabaseIdSynonymsItemsById.g.cs | 403 +++++++++----
 ...chClient.GetByDatabaseIdSynonymsItems.g.cs | 391 +++++++++----
 .../Generated/Recombee.SearchClient.g.cs      |  29 +
 .../Recombee/Generated/Recombee.Security.g.cs |  15 +-
 ...SegmentationsAutoReqlBySegmentationId.g.cs | 478 +++++++++++-----
 ...gmentationsManualReqlBySegmentationId.g.cs | 478 +++++++++++-----
 ...qlBySegmentationIdSegmentsBySegmentId.g.cs | 480 +++++++++++-----
 ...ntationsPropertyBasedBySegmentationId.g.cs | 478 +++++++++++-----
 ...tabaseIdSegmentationsBySegmentationId.g.cs | 403 +++++++++----
 ...qlBySegmentationIdSegmentsBySegmentId.g.cs | 463 ++++++++++-----
 ...ient.GetByDatabaseIdSegmentationsList.g.cs | 387 +++++++++----
 ...seIdSegmentationsListBySegmentationId.g.cs | 431 ++++++++++----
 ...SegmentationsAutoReqlBySegmentationId.g.cs | 420 ++++++++++----
 ...gmentationsManualReqlBySegmentationId.g.cs | 420 ++++++++++----
 ...qlBySegmentationIdSegmentsBySegmentId.g.cs | 480 +++++++++++-----
 ...ntationsPropertyBasedBySegmentationId.g.cs | 478 +++++++++++-----
 ...ecombee.SegmentationsDefinitionClient.g.cs |  29 +
 ...eateByDatabaseIdSeriesBySeriesIdItems.g.cs | 538 ++++++++++++------
 ...nt.DeleteByDatabaseIdSeriesBySeriesId.g.cs | 478 +++++++++++-----
 ...leteByDatabaseIdSeriesBySeriesIdItems.g.cs | 478 +++++++++++-----
 ....GetByDatabaseIdSeriesBySeriesIdItems.g.cs | 491 +++++++++++-----
 ...eriesClient.GetByDatabaseIdSeriesList.g.cs | 429 ++++++++++----
 ...lient.PutByDatabaseIdSeriesBySeriesId.g.cs | 478 +++++++++++-----
 .../Generated/Recombee.SeriesClient.g.cs      |  29 +
 ...onsClient.CreateByDatabaseIdBookmarks.g.cs | 536 +++++++++++------
 ...lient.CreateByDatabaseIdCartadditions.g.cs | 536 +++++++++++------
 ...sClient.CreateByDatabaseIdDetailviews.g.cs | 536 +++++++++++------
 ...onsClient.CreateByDatabaseIdPurchases.g.cs | 536 +++++++++++------
 ...tionsClient.CreateByDatabaseIdRatings.g.cs | 536 +++++++++++------
 ...Client.CreateByDatabaseIdViewportions.g.cs | 536 +++++++++++------
 ...onsClient.DeleteByDatabaseIdBookmarks.g.cs | 475 +++++++++++-----
 ...lient.DeleteByDatabaseIdCartadditions.g.cs | 475 +++++++++++-----
 ...sClient.DeleteByDatabaseIdDetailviews.g.cs | 475 +++++++++++-----
 ...onsClient.DeleteByDatabaseIdPurchases.g.cs | 475 +++++++++++-----
 ...tionsClient.DeleteByDatabaseIdRatings.g.cs | 475 +++++++++++-----
 ...Client.DeleteByDatabaseIdViewportions.g.cs | 475 +++++++++++-----
 ...GetByDatabaseIdItemsByItemIdBookmarks.g.cs | 491 +++++++++++-----
 ...yDatabaseIdItemsByItemIdCartadditions.g.cs | 491 +++++++++++-----
 ...tByDatabaseIdItemsByItemIdDetailviews.g.cs | 491 +++++++++++-----
 ...GetByDatabaseIdItemsByItemIdPurchases.g.cs | 491 +++++++++++-----
 ...t.GetByDatabaseIdItemsByItemIdRatings.g.cs | 491 +++++++++++-----
 ...ByDatabaseIdItemsByItemIdViewportions.g.cs | 491 +++++++++++-----
 ...GetByDatabaseIdUsersByUserIdBookmarks.g.cs | 491 +++++++++++-----
 ...yDatabaseIdUsersByUserIdCartadditions.g.cs | 491 +++++++++++-----
 ...tByDatabaseIdUsersByUserIdDetailviews.g.cs | 491 +++++++++++-----
 ...GetByDatabaseIdUsersByUserIdPurchases.g.cs | 491 +++++++++++-----
 ...t.GetByDatabaseIdUsersByUserIdRatings.g.cs | 491 +++++++++++-----
 ...ByDatabaseIdUsersByUserIdViewportions.g.cs | 491 +++++++++++-----
 .../Recombee.UserItemInteractionsClient.g.cs  |  29 +
 ...lient.CreateByDatabaseIdUsersByUserId.g.cs | 483 +++++++++++-----
 ...tabaseIdUsersPropertiesByPropertyName.g.cs | 461 ++++++++++-----
 ...esClient.GetByDatabaseIdUsersByUserId.g.cs | 483 +++++++++++-----
 ...tabaseIdUsersPropertiesByPropertyName.g.cs | 491 +++++++++++-----
 ...nt.GetByDatabaseIdUsersPropertiesList.g.cs | 429 ++++++++++----
 ...tabaseIdUsersPropertiesByPropertyName.g.cs | 469 ++++++++++-----
 .../Recombee.UserPropertiesClient.g.cs        |  29 +
 ...lient.DeleteByDatabaseIdUsersByUserId.g.cs | 461 ++++++++++-----
 ....UsersClient.GetByDatabaseIdUsersList.g.cs | 453 ++++++++++-----
 ...sersByTargetUserIdMergeBySourceUserId.g.cs | 471 ++++++++++-----
 ...rsClient.PutByDatabaseIdUsersByUserId.g.cs | 461 ++++++++++-----
 .../Generated/Recombee.UsersClient.g.cs       |  29 +
 190 files changed, 28189 insertions(+), 11996 deletions(-)
 create mode 100644 src/libs/Recombee/Generated/Recombee.OptionsSupport.g.cs

diff --git a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.CreateByDatabaseIdItemsByItemId.g.cs b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.CreateByDatabaseIdItemsByItemId.g.cs
index f395d30..2aa0259 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.CreateByDatabaseIdItemsByItemId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.CreateByDatabaseIdItemsByItemId.g.cs
@@ -12,6 +12,7 @@ public partial interface IItemPropertiesClient
         /// <param name="itemId"></param>
         /// <param name="cascadeCreate"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdItemsByItemIdAsync(
@@ -20,6 +21,7 @@ public partial interface IItemPropertiesClient
 
             string request,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.CreateByDatabaseIdMoreItems.g.cs b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.CreateByDatabaseIdMoreItems.g.cs
index 1e470b4..0fc339c 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.CreateByDatabaseIdMoreItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.CreateByDatabaseIdMoreItems.g.cs
@@ -17,12 +17,14 @@ public partial interface IItemPropertiesClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.UpdateMoreItemsResponse> CreateByDatabaseIdMoreItemsAsync(
             string databaseId,
 
             global::Recombee.UpdateMoreItemsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Update More Items<br/>
@@ -42,12 +44,14 @@ public partial interface IItemPropertiesClient
         /// <param name="changes">
         /// A dictionary where the keys are properties that shall be updated.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.UpdateMoreItemsResponse> CreateByDatabaseIdMoreItemsAsync(
             string databaseId,
             string filter,
             object changes,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.DeleteByDatabaseIdItemsPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.DeleteByDatabaseIdItemsPropertiesByPropertyName.g.cs
index 7ad1134..ef41072 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.DeleteByDatabaseIdItemsPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.DeleteByDatabaseIdItemsPropertiesByPropertyName.g.cs
@@ -10,11 +10,13 @@ public partial interface IItemPropertiesClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdItemsPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsByItemId.g.cs b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsByItemId.g.cs
index e10f82e..f00e726 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsByItemId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsByItemId.g.cs
@@ -10,11 +10,13 @@ public partial interface IItemPropertiesClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<string> GetByDatabaseIdItemsByItemIdAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsPropertiesByPropertyName.g.cs
index 561cb81..6da506e 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsPropertiesByPropertyName.g.cs
@@ -10,11 +10,13 @@ public partial interface IItemPropertiesClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.PropertyInfo> GetByDatabaseIdItemsPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsPropertiesList.g.cs b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsPropertiesList.g.cs
index 992a7a3..0b9b6e8 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsPropertiesList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.GetByDatabaseIdItemsPropertiesList.g.cs
@@ -9,10 +9,12 @@ public partial interface IItemPropertiesClient
         /// Gets the list of all the item properties in your database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>> GetByDatabaseIdItemsPropertiesListAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.PutByDatabaseIdItemsPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.PutByDatabaseIdItemsPropertiesByPropertyName.g.cs
index b6add13..b9963c6 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.PutByDatabaseIdItemsPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.PutByDatabaseIdItemsPropertiesByPropertyName.g.cs
@@ -11,12 +11,14 @@ public partial interface IItemPropertiesClient
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></param>
         /// <param name="type"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdItemsPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
             global::Recombee.PutItemsPropertiesType type,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.g.cs b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.g.cs
index df22eca..f565b9b 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemPropertiesClient.g.cs
@@ -33,6 +33,11 @@ public partial interface IItemPropertiesClient : global::System.IDisposable
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.IItemsClient.DeleteByDatabaseIdItemsByItemId.g.cs b/src/libs/Recombee/Generated/Recombee.IItemsClient.DeleteByDatabaseIdItemsByItemId.g.cs
index 8ec9ead..db96263 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemsClient.DeleteByDatabaseIdItemsByItemId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemsClient.DeleteByDatabaseIdItemsByItemId.g.cs
@@ -12,11 +12,13 @@ public partial interface IItemsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdItemsByItemIdAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemsClient.DeleteByDatabaseIdMoreItems.g.cs b/src/libs/Recombee/Generated/Recombee.IItemsClient.DeleteByDatabaseIdMoreItems.g.cs
index 1f473ad..b46de47 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemsClient.DeleteByDatabaseIdMoreItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemsClient.DeleteByDatabaseIdMoreItems.g.cs
@@ -11,12 +11,14 @@ public partial interface IItemsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.DeleteMoreItemsResponse> DeleteByDatabaseIdMoreItemsAsync(
             string databaseId,
 
             global::Recombee.DeleteMoreItemsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Delete More Items<br/>
@@ -27,11 +29,13 @@ public partial interface IItemsClient
         /// <param name="filter">
         /// A [ReQL](https://docs.recombee.com/reql) expression, which returns `true` for the items that shall be updated.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.DeleteMoreItemsResponse> DeleteByDatabaseIdMoreItemsAsync(
             string databaseId,
             string filter,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemsClient.GetByDatabaseIdItemsList.g.cs b/src/libs/Recombee/Generated/Recombee.IItemsClient.GetByDatabaseIdItemsList.g.cs
index d055c09..4f86ff2 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemsClient.GetByDatabaseIdItemsList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemsClient.GetByDatabaseIdItemsList.g.cs
@@ -14,6 +14,7 @@ public partial interface IItemsClient
         /// <param name="offset"></param>
         /// <param name="returnProperties"></param>
         /// <param name="includedProperties"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Item>> GetByDatabaseIdItemsListAsync(
@@ -23,6 +24,7 @@ public partial interface IItemsClient
             int? offset = default,
             bool? returnProperties = default,
             global::System.Collections.Generic.IList<string>? includedProperties = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemsClient.PutByDatabaseIdItemsByItemId.g.cs b/src/libs/Recombee/Generated/Recombee.IItemsClient.PutByDatabaseIdItemsByItemId.g.cs
index 47df5cd..534a3d1 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemsClient.PutByDatabaseIdItemsByItemId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemsClient.PutByDatabaseIdItemsByItemId.g.cs
@@ -11,11 +11,13 @@ public partial interface IItemsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdItemsByItemIdAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IItemsClient.g.cs b/src/libs/Recombee/Generated/Recombee.IItemsClient.g.cs
index 3e9a4d6..7ee3bba 100644
--- a/src/libs/Recombee/Generated/Recombee.IItemsClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IItemsClient.g.cs
@@ -33,6 +33,11 @@ public partial interface IItemsClient : global::System.IDisposable
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.CreateByDatabaseIdBatch.g.cs b/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.CreateByDatabaseIdBatch.g.cs
index 82ed0bc..9b73662 100644
--- a/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.CreateByDatabaseIdBatch.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.CreateByDatabaseIdBatch.g.cs
@@ -12,12 +12,14 @@ public partial interface IMiscellaneousClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdBatchAsync(
             string databaseId,
 
             global::Recombee.Batch request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Batch<br/>
@@ -32,12 +34,14 @@ public partial interface IMiscellaneousClient
         /// <param name="distinctRecomms">
         /// Makes all the recommended items for a certain user distinct among multiple recommendation requests in the batch.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdBatchAsync(
             string databaseId,
             global::System.Collections.Generic.IList<object> requests,
             bool? distinctRecomms = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.DeleteByDatabaseId.g.cs b/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.DeleteByDatabaseId.g.cs
index 45c04ab..3d757a4 100644
--- a/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.DeleteByDatabaseId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.DeleteByDatabaseId.g.cs
@@ -9,10 +9,12 @@ public partial interface IMiscellaneousClient
         /// Completely erases all your data, including items, item properties, series, user database, purchases, ratings, detail views, and bookmarks. Make sure the request is never executed in the production environment! Resetting your database is irreversible.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.GetByDatabaseIdScenarios.g.cs b/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.GetByDatabaseIdScenarios.g.cs
index d6186c6..60e5975 100644
--- a/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.GetByDatabaseIdScenarios.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.GetByDatabaseIdScenarios.g.cs
@@ -9,10 +9,12 @@ public partial interface IMiscellaneousClient
         /// Get all [Scenarios](https://docs.recombee.com/scenarios) of the given database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Scenario>> GetByDatabaseIdScenariosAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.g.cs b/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.g.cs
index c36acef..0d93514 100644
--- a/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IMiscellaneousClient.g.cs
@@ -33,6 +33,11 @@ public partial interface IMiscellaneousClient : global::System.IDisposable
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.IRecombeeClient.g.cs b/src/libs/Recombee/Generated/Recombee.IRecombeeClient.g.cs
index c39e387..2d4f4fb 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecombeeClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecombeeClient.g.cs
@@ -36,6 +36,11 @@ public partial interface IRecombeeClient : global::System.IDisposable
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsComposite.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsComposite.g.cs
index efccf22..9df30f5 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsComposite.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsComposite.g.cs
@@ -27,12 +27,14 @@ public partial interface IRecommendationsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.CompositeRecommendationResponse> CreateByDatabaseIdRecommsCompositeAsync(
             string databaseId,
 
             global::Recombee.CompositeRecommendationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Composite Recommendation<br/>
@@ -86,6 +88,7 @@ public partial interface IRecommendationsClient
         /// <param name="expertSettings">
         /// Dictionary of custom options.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.CompositeRecommendationResponse> CreateByDatabaseIdRecommsCompositeAsync(
@@ -100,6 +103,7 @@ public partial interface IRecommendationsClient
             object? sourceSettings = default,
             object? resultSettings = default,
             object? expertSettings = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItemSegments.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItemSegments.g.cs
index d2adb2e..9c55b9d 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItemSegments.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItemSegments.g.cs
@@ -17,12 +17,14 @@ public partial interface IRecommendationsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync(
             string databaseId,
 
             global::Recombee.RecommendItemSegmentsToItemSegmentParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Recommend Item Segments to Item Segment<br/>
@@ -113,6 +115,7 @@ public partial interface IRecommendationsClient
         /// }<br/>
         /// ```
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync(
@@ -128,6 +131,7 @@ public partial interface IRecommendationsClient
             object? expertSettings = default,
             bool? returnAbGroup = default,
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItems.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItems.g.cs
index d941851..fcf23f9 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItems.g.cs
@@ -17,12 +17,14 @@ public partial interface IRecommendationsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemSegmentsItemsAsync(
             string databaseId,
 
             global::Recombee.RecommendItemsToItemSegmentParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Recommend Items to Item Segment<br/>
@@ -185,6 +187,7 @@ public partial interface IRecommendationsClient
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemSegmentsItemsAsync(
@@ -205,6 +208,7 @@ public partial interface IRecommendationsClient
             double? rotationTime = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItemSegments.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItemSegments.g.cs
index a7d6cbb..940c9a8 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItemSegments.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItemSegments.g.cs
@@ -19,6 +19,7 @@ public partial interface IRecommendationsClient
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync(
@@ -26,6 +27,7 @@ public partial interface IRecommendationsClient
             string itemId,
 
             global::Recombee.RecommendItemSegmentsToItemParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Recommend Item Segments to Item<br/>
@@ -115,6 +117,7 @@ public partial interface IRecommendationsClient
         /// }<br/>
         /// ```
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync(
@@ -130,6 +133,7 @@ public partial interface IRecommendationsClient
             object? expertSettings = default,
             bool? returnAbGroup = default,
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItems.g.cs
index 6b206a4..0b13fed 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItems.g.cs
@@ -16,6 +16,7 @@ public partial interface IRecommendationsClient
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdItemsAsync(
@@ -23,6 +24,7 @@ public partial interface IRecommendationsClient
             string itemId,
 
             global::Recombee.RecommendItemsToItemParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Recommend Items to Item<br/>
@@ -190,6 +192,7 @@ public partial interface IRecommendationsClient
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdItemsAsync(
@@ -212,6 +215,7 @@ public partial interface IRecommendationsClient
             double? rotationTime = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdUsers.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdUsers.g.cs
index 5092095..a674339 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdUsers.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdUsers.g.cs
@@ -13,6 +13,7 @@ public partial interface IRecommendationsClient
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdUsersAsync(
@@ -20,6 +21,7 @@ public partial interface IRecommendationsClient
             string itemId,
 
             global::Recombee.RecommendUsersToItemParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Recommend Users to Item<br/>
@@ -151,6 +153,7 @@ public partial interface IRecommendationsClient
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdUsersAsync(
@@ -168,6 +171,7 @@ public partial interface IRecommendationsClient
             double? diversity = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsNextItemsByRecommId.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsNextItemsByRecommId.g.cs
index 8059acc..abb8447 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsNextItemsByRecommId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsNextItemsByRecommId.g.cs
@@ -22,6 +22,7 @@ public partial interface IRecommendationsClient
         /// <param name="databaseId"></param>
         /// <param name="recommId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsNextItemsByRecommIdAsync(
@@ -29,6 +30,7 @@ public partial interface IRecommendationsClient
             string recommId,
 
             global::Recombee.RecommendNextItemsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Recommend Next Items<br/>
@@ -50,12 +52,14 @@ public partial interface IRecommendationsClient
         /// <param name="count">
         /// Number of items to be recommended
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsNextItemsByRecommIdAsync(
             string databaseId,
             string recommId,
             int count,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItemSegments.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItemSegments.g.cs
index 4fde7a9..37263ce 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItemSegments.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItemSegments.g.cs
@@ -19,6 +19,7 @@ public partial interface IRecommendationsClient
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync(
@@ -26,6 +27,7 @@ public partial interface IRecommendationsClient
             string userId,
 
             global::Recombee.RecommendItemSegmentsToUserParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Recommend Item Segments to User<br/>
@@ -100,6 +102,7 @@ public partial interface IRecommendationsClient
         /// }<br/>
         /// ```
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync(
@@ -114,6 +117,7 @@ public partial interface IRecommendationsClient
             object? expertSettings = default,
             bool? returnAbGroup = default,
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItems.g.cs
index 6836752..316363c 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItems.g.cs
@@ -17,6 +17,7 @@ public partial interface IRecommendationsClient
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdItemsAsync(
@@ -24,6 +25,7 @@ public partial interface IRecommendationsClient
             string userId,
 
             global::Recombee.RecommendItemsToUserParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Recommend Items to User<br/>
@@ -171,6 +173,7 @@ public partial interface IRecommendationsClient
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdItemsAsync(
@@ -191,6 +194,7 @@ public partial interface IRecommendationsClient
             double? rotationTime = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdUsers.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdUsers.g.cs
index 171e2e7..e9f257d 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdUsers.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdUsers.g.cs
@@ -13,6 +13,7 @@ public partial interface IRecommendationsClient
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdUsersAsync(
@@ -20,6 +21,7 @@ public partial interface IRecommendationsClient
             string userId,
 
             global::Recombee.RecommendUsersToUserParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Recommend Users to User<br/>
@@ -157,6 +159,7 @@ public partial interface IRecommendationsClient
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdUsersAsync(
@@ -177,6 +180,7 @@ public partial interface IRecommendationsClient
             double? rotationTime = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.g.cs b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.g.cs
index 72c35b8..522f772 100644
--- a/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IRecommendationsClient.g.cs
@@ -33,6 +33,11 @@ public partial interface IRecommendationsClient : global::System.IDisposable
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSearchUsersByUserIdItemSegments.g.cs b/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSearchUsersByUserIdItemSegments.g.cs
index 9b23f5f..e1fba8b 100644
--- a/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSearchUsersByUserIdItemSegments.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSearchUsersByUserIdItemSegments.g.cs
@@ -18,6 +18,7 @@ public partial interface ISearchClient
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.SearchResponse> CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync(
@@ -25,6 +26,7 @@ public partial interface ISearchClient
             string userId,
 
             global::Recombee.SearchItemSegmentsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Search Item Segments<br/>
@@ -101,6 +103,7 @@ public partial interface ISearchClient
         /// }<br/>
         /// ```
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.SearchResponse> CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync(
@@ -116,6 +119,7 @@ public partial interface ISearchClient
             object? expertSettings = default,
             bool? returnAbGroup = default,
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSearchUsersByUserIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSearchUsersByUserIdItems.g.cs
index f995f6c..3fe89fc 100644
--- a/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSearchUsersByUserIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSearchUsersByUserIdItems.g.cs
@@ -18,6 +18,7 @@ public partial interface ISearchClient
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.SearchResponse> CreateByDatabaseIdSearchUsersByUserIdItemsAsync(
@@ -25,6 +26,7 @@ public partial interface ISearchClient
             string userId,
 
             global::Recombee.SearchItemsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Search Items<br/>
@@ -164,6 +166,7 @@ public partial interface ISearchClient
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.SearchResponse> CreateByDatabaseIdSearchUsersByUserIdItemsAsync(
@@ -181,6 +184,7 @@ public partial interface ISearchClient
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSynonymsItems.g.cs b/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSynonymsItems.g.cs
index a5ab39a..7c01c7d 100644
--- a/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSynonymsItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISearchClient.CreateByDatabaseIdSynonymsItems.g.cs
@@ -13,12 +13,14 @@ public partial interface ISearchClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.SearchSynonym> CreateByDatabaseIdSynonymsItemsAsync(
             string databaseId,
 
             global::Recombee.SearchSynonymParams request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Add Search Synonym<br/>
@@ -38,6 +40,7 @@ public partial interface ISearchClient
         /// If set to `true`, only `term` -&gt; `synonym` is considered. If set to `false`, also `synonym` -&gt; `term` works.<br/>
         /// Default: `false`.
         /// </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>
         global::System.Threading.Tasks.Task<global::Recombee.SearchSynonym> CreateByDatabaseIdSynonymsItemsAsync(
@@ -45,6 +48,7 @@ public partial interface ISearchClient
             string term,
             string synonym,
             bool? oneWay = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISearchClient.DeleteByDatabaseIdSynonymsItems.g.cs b/src/libs/Recombee/Generated/Recombee.ISearchClient.DeleteByDatabaseIdSynonymsItems.g.cs
index 0d8ad31..668d75a 100644
--- a/src/libs/Recombee/Generated/Recombee.ISearchClient.DeleteByDatabaseIdSynonymsItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISearchClient.DeleteByDatabaseIdSynonymsItems.g.cs
@@ -9,10 +9,12 @@ public partial interface ISearchClient
         /// Deletes all synonyms defined in the database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdSynonymsItemsAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISearchClient.DeleteByDatabaseIdSynonymsItemsById.g.cs b/src/libs/Recombee/Generated/Recombee.ISearchClient.DeleteByDatabaseIdSynonymsItemsById.g.cs
index 04b8079..69393f1 100644
--- a/src/libs/Recombee/Generated/Recombee.ISearchClient.DeleteByDatabaseIdSynonymsItemsById.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISearchClient.DeleteByDatabaseIdSynonymsItemsById.g.cs
@@ -10,11 +10,13 @@ public partial interface ISearchClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="id"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdSynonymsItemsByIdAsync(
             string databaseId,
             string id,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISearchClient.GetByDatabaseIdSynonymsItems.g.cs b/src/libs/Recombee/Generated/Recombee.ISearchClient.GetByDatabaseIdSynonymsItems.g.cs
index f037260..7e416e9 100644
--- a/src/libs/Recombee/Generated/Recombee.ISearchClient.GetByDatabaseIdSynonymsItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISearchClient.GetByDatabaseIdSynonymsItems.g.cs
@@ -11,12 +11,14 @@ public partial interface ISearchClient
         /// <param name="databaseId"></param>
         /// <param name="count"></param>
         /// <param name="offset"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.ListSearchSynonymsResponse> GetByDatabaseIdSynonymsItemsAsync(
             string databaseId,
             int? count = default,
             int? offset = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISearchClient.g.cs b/src/libs/Recombee/Generated/Recombee.ISearchClient.g.cs
index 19f4c1c..d5ade3c 100644
--- a/src/libs/Recombee/Generated/Recombee.ISearchClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISearchClient.g.cs
@@ -33,6 +33,11 @@ public partial interface ISearchClient : global::System.IDisposable
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
index cb77dca..bb51559 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
@@ -11,6 +11,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
@@ -18,6 +19,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentationId,
 
             global::Recombee.UpdateAutoReQLSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Update Auto ReQL Segmentation<br/>
@@ -34,6 +36,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
@@ -42,6 +45,7 @@ public partial interface ISegmentationsDefinitionClient
             string? expression = default,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
index b31fa33..20a19ee 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
@@ -11,6 +11,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
@@ -18,6 +19,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentationId,
 
             global::Recombee.UpdateManualReQLSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Update Manual ReQL Segmentation<br/>
@@ -31,6 +33,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
@@ -38,6 +41,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentationId,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
index f38a39f..e46580f 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
@@ -12,6 +12,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="segmentationId"></param>
         /// <param name="segmentId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
@@ -20,6 +21,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentId,
 
             global::Recombee.ManualReQLSegmentParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Update Manual ReQL Segment<br/>
@@ -34,6 +36,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="title">
         /// Human-readable name of the Segment that is shown in the Recombee Admin UI.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
@@ -42,6 +45,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentId,
             string filter,
             string? title = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
index 5255220..27de5a3 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
@@ -11,6 +11,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
@@ -18,6 +19,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentationId,
 
             global::Recombee.UpdatePropertyBasedSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Update Property Based Segmentation<br/>
@@ -34,6 +36,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
@@ -42,6 +45,7 @@ public partial interface ISegmentationsDefinitionClient
             string? propertyName = default,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsBySegmentationId.g.cs
index 7c7ae7b..c90c2ae 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsBySegmentationId.g.cs
@@ -10,11 +10,13 @@ public partial interface ISegmentationsDefinitionClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdSegmentationsBySegmentationIdAsync(
             string databaseId,
             string segmentationId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
index 602b14b..83d77cd 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
@@ -11,12 +11,14 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></param>
         /// <param name="segmentId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
             string databaseId,
             string segmentationId,
             string segmentId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.GetByDatabaseIdSegmentationsList.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.GetByDatabaseIdSegmentationsList.g.cs
index e33922a..5efdcb7 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.GetByDatabaseIdSegmentationsList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.GetByDatabaseIdSegmentationsList.g.cs
@@ -10,11 +10,13 @@ public partial interface ISegmentationsDefinitionClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="sourceType"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.ListSegmentationsResponse> GetByDatabaseIdSegmentationsListAsync(
             string databaseId,
             string sourceType,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.GetByDatabaseIdSegmentationsListBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.GetByDatabaseIdSegmentationsListBySegmentationId.g.cs
index 2face4b..280b0e5 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.GetByDatabaseIdSegmentationsListBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.GetByDatabaseIdSegmentationsListBySegmentationId.g.cs
@@ -10,11 +10,13 @@ public partial interface ISegmentationsDefinitionClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.Segmentation> GetByDatabaseIdSegmentationsListBySegmentationIdAsync(
             string databaseId,
             string segmentationId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
index 7cefddd..0547acb 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
@@ -12,6 +12,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
@@ -19,6 +20,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentationId,
 
             global::Recombee.CreateAutoReQLSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Create Auto ReQL Segmentation<br/>
@@ -39,6 +41,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
@@ -48,6 +51,7 @@ public partial interface ISegmentationsDefinitionClient
             string expression,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
index 2cbc998..69c5b7d 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
@@ -12,6 +12,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
@@ -19,6 +20,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentationId,
 
             global::Recombee.CreateManualReQLSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Create Manual ReQL Segmentation<br/>
@@ -36,6 +38,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
@@ -44,6 +47,7 @@ public partial interface ISegmentationsDefinitionClient
             string sourceType,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
index c95d0d5..62d2db3 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
@@ -13,6 +13,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="segmentationId"></param>
         /// <param name="segmentId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
@@ -21,6 +22,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentId,
 
             global::Recombee.ManualReQLSegmentParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Add Manual ReQL Segment<br/>
@@ -36,6 +38,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="title">
         /// Human-readable name of the Segment that is shown in the Recombee Admin UI.
         /// </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>
         global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
@@ -44,6 +47,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentId,
             string filter,
             string? title = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
index 34ed801..ee7a523 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.PutByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
@@ -13,6 +13,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
@@ -20,6 +21,7 @@ public partial interface ISegmentationsDefinitionClient
             string segmentationId,
 
             global::Recombee.CreatePropertyBasedSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Create Property Based Segmentation<br/>
@@ -41,6 +43,7 @@ public partial interface ISegmentationsDefinitionClient
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
@@ -50,6 +53,7 @@ public partial interface ISegmentationsDefinitionClient
             string propertyName,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.g.cs b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.g.cs
index c1b2acd..83a3426 100644
--- a/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISegmentationsDefinitionClient.g.cs
@@ -33,6 +33,11 @@ public partial interface ISegmentationsDefinitionClient : global::System.IDispos
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.ISeriesClient.CreateByDatabaseIdSeriesBySeriesIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.ISeriesClient.CreateByDatabaseIdSeriesBySeriesIdItems.g.cs
index 3027963..21d30fe 100644
--- a/src/libs/Recombee/Generated/Recombee.ISeriesClient.CreateByDatabaseIdSeriesBySeriesIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISeriesClient.CreateByDatabaseIdSeriesBySeriesIdItems.g.cs
@@ -11,6 +11,7 @@ public partial interface ISeriesClient
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSeriesBySeriesIdItemsAsync(
@@ -18,6 +19,7 @@ public partial interface ISeriesClient
             string seriesId,
 
             global::Recombee.SeriesItem request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Insert to Series<br/>
@@ -37,6 +39,7 @@ public partial interface ISeriesClient
         /// <param name="cascadeCreate">
         /// Indicates that any non-existing entity specified within the request should be created (as if corresponding PUT requests were invoked). This concerns both the `seriesId` and the `itemId`. If `cascadeCreate` is set to true, the behavior also depends on the `itemType`. In case of `item`, an item is created, in case of `series` a series + corresponding item with the same ID is created.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdSeriesBySeriesIdItemsAsync(
@@ -46,6 +49,7 @@ public partial interface ISeriesClient
             string itemId,
             double time,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISeriesClient.DeleteByDatabaseIdSeriesBySeriesId.g.cs b/src/libs/Recombee/Generated/Recombee.ISeriesClient.DeleteByDatabaseIdSeriesBySeriesId.g.cs
index 760e577..30f2117 100644
--- a/src/libs/Recombee/Generated/Recombee.ISeriesClient.DeleteByDatabaseIdSeriesBySeriesId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISeriesClient.DeleteByDatabaseIdSeriesBySeriesId.g.cs
@@ -12,6 +12,7 @@ public partial interface ISeriesClient
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdSeriesBySeriesIdAsync(
@@ -19,6 +20,7 @@ public partial interface ISeriesClient
             string seriesId,
 
             global::Recombee.DeleteSeries request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Delete Series<br/>
@@ -30,12 +32,14 @@ public partial interface ISeriesClient
         /// <param name="cascadeDelete">
         /// If set to `true`, item with the same ID as seriesId will be also deleted. Default is `false`.
         /// </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>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdSeriesBySeriesIdAsync(
             string databaseId,
             string seriesId,
             bool? cascadeDelete = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISeriesClient.DeleteByDatabaseIdSeriesBySeriesIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.ISeriesClient.DeleteByDatabaseIdSeriesBySeriesIdItems.g.cs
index 8344d9f..50d5343 100644
--- a/src/libs/Recombee/Generated/Recombee.ISeriesClient.DeleteByDatabaseIdSeriesBySeriesIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISeriesClient.DeleteByDatabaseIdSeriesBySeriesIdItems.g.cs
@@ -11,6 +11,7 @@ public partial interface ISeriesClient
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdSeriesBySeriesIdItemsAsync(
@@ -18,6 +19,7 @@ public partial interface ISeriesClient
             string seriesId,
 
             global::Recombee.RemoveSeriesItem request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Remove from Series<br/>
@@ -31,6 +33,7 @@ public partial interface ISeriesClient
         /// <param name="itemId">
         /// ID of the item iff `itemType` is `item`. ID of the series iff `itemType` is `series`.
         /// </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>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdSeriesBySeriesIdItemsAsync(
@@ -38,6 +41,7 @@ public partial interface ISeriesClient
             string seriesId,
             string itemType,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISeriesClient.GetByDatabaseIdSeriesBySeriesIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.ISeriesClient.GetByDatabaseIdSeriesBySeriesIdItems.g.cs
index e570e99..8acda86 100644
--- a/src/libs/Recombee/Generated/Recombee.ISeriesClient.GetByDatabaseIdSeriesBySeriesIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISeriesClient.GetByDatabaseIdSeriesBySeriesIdItems.g.cs
@@ -10,11 +10,13 @@ public partial interface ISeriesClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.SeriesItem>> GetByDatabaseIdSeriesBySeriesIdItemsAsync(
             string databaseId,
             string seriesId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISeriesClient.GetByDatabaseIdSeriesList.g.cs b/src/libs/Recombee/Generated/Recombee.ISeriesClient.GetByDatabaseIdSeriesList.g.cs
index 3d1a466..6cc06f8 100644
--- a/src/libs/Recombee/Generated/Recombee.ISeriesClient.GetByDatabaseIdSeriesList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISeriesClient.GetByDatabaseIdSeriesList.g.cs
@@ -9,10 +9,12 @@ public partial interface ISeriesClient
         /// Gets the list of all the series currently present in the database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Series>> GetByDatabaseIdSeriesListAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISeriesClient.PutByDatabaseIdSeriesBySeriesId.g.cs b/src/libs/Recombee/Generated/Recombee.ISeriesClient.PutByDatabaseIdSeriesBySeriesId.g.cs
index 81a83b9..ae0efbb 100644
--- a/src/libs/Recombee/Generated/Recombee.ISeriesClient.PutByDatabaseIdSeriesBySeriesId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISeriesClient.PutByDatabaseIdSeriesBySeriesId.g.cs
@@ -11,6 +11,7 @@ public partial interface ISeriesClient
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdSeriesBySeriesIdAsync(
@@ -18,6 +19,7 @@ public partial interface ISeriesClient
             string seriesId,
 
             global::Recombee.AddSeries request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Add Series<br/>
@@ -28,12 +30,14 @@ public partial interface ISeriesClient
         /// <param name="cascadeCreate">
         /// If set to `true`, the item will be created with the same ID as the series. Default is `true`.
         /// </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>
         global::System.Threading.Tasks.Task PutByDatabaseIdSeriesBySeriesIdAsync(
             string databaseId,
             string seriesId,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ISeriesClient.g.cs b/src/libs/Recombee/Generated/Recombee.ISeriesClient.g.cs
index 57578ed..08c778c 100644
--- a/src/libs/Recombee/Generated/Recombee.ISeriesClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ISeriesClient.g.cs
@@ -33,6 +33,11 @@ public partial interface ISeriesClient : global::System.IDisposable
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdBookmarks.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdBookmarks.g.cs
index bb5c638..1e12756 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdBookmarks.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdBookmarks.g.cs
@@ -10,12 +10,14 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdBookmarksAsync(
             string databaseId,
 
             global::Recombee.Bookmark request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Add Bookmark<br/>
@@ -40,6 +42,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="additionalData">
         /// A dictionary of additional data for the interaction.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdBookmarksAsync(
@@ -50,6 +53,7 @@ public partial interface IUserItemInteractionsClient
             bool? cascadeCreate = default,
             string? recommId = default,
             object? additionalData = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdCartadditions.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdCartadditions.g.cs
index b88c288..b740caf 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdCartadditions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdCartadditions.g.cs
@@ -10,12 +10,14 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdCartadditionsAsync(
             string databaseId,
 
             global::Recombee.CartAddition request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Add Cart Addition<br/>
@@ -46,6 +48,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="additionalData">
         /// A dictionary of additional data for the interaction.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdCartadditionsAsync(
@@ -58,6 +61,7 @@ public partial interface IUserItemInteractionsClient
             double? price = default,
             string? recommId = default,
             object? additionalData = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdDetailviews.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdDetailviews.g.cs
index 0b1ec16..086bf35 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdDetailviews.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdDetailviews.g.cs
@@ -10,12 +10,14 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdDetailviewsAsync(
             string databaseId,
 
             global::Recombee.DetailView request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Add Detail View<br/>
@@ -46,6 +48,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="autoPresented">
         /// Indicates whether the item was automatically presented to the user (e.g., in a swiping feed) or explicitly requested by the user (e.g., by clicking on a link). Defaults to `false`.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdDetailviewsAsync(
@@ -58,6 +61,7 @@ public partial interface IUserItemInteractionsClient
             string? recommId = default,
             object? additionalData = default,
             bool? autoPresented = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdPurchases.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdPurchases.g.cs
index 0902bbb..df8a672 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdPurchases.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdPurchases.g.cs
@@ -10,12 +10,14 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdPurchasesAsync(
             string databaseId,
 
             global::Recombee.Purchase request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Add Purchase<br/>
@@ -49,6 +51,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="additionalData">
         /// A dictionary of additional data for the interaction.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdPurchasesAsync(
@@ -62,6 +65,7 @@ public partial interface IUserItemInteractionsClient
             double? profit = default,
             string? recommId = default,
             object? additionalData = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdRatings.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdRatings.g.cs
index 1b26009..bab8cc2 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdRatings.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdRatings.g.cs
@@ -10,12 +10,14 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdRatingsAsync(
             string databaseId,
 
             global::Recombee.Rating request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Add Rating<br/>
@@ -43,6 +45,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="additionalData">
         /// A dictionary of additional data for the interaction.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdRatingsAsync(
@@ -54,6 +57,7 @@ public partial interface IUserItemInteractionsClient
             bool? cascadeCreate = default,
             string? recommId = default,
             object? additionalData = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdViewportions.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdViewportions.g.cs
index 59b7b24..be37d86 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdViewportions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.CreateByDatabaseIdViewportions.g.cs
@@ -11,12 +11,14 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdViewportionsAsync(
             string databaseId,
 
             global::Recombee.ViewPortion request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
         /// <summary>
         /// Set View Portion<br/>
@@ -54,6 +56,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="timeSpent">
         /// The duration (in seconds) that the user viewed the item. In update requests, this value may only increase and is required only if it has changed.
         /// </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>
         global::System.Threading.Tasks.Task CreateByDatabaseIdViewportionsAsync(
@@ -68,6 +71,7 @@ public partial interface IUserItemInteractionsClient
             object? additionalData = default,
             bool? autoPresented = default,
             double? timeSpent = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdBookmarks.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdBookmarks.g.cs
index 506814c..898ae97 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdBookmarks.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdBookmarks.g.cs
@@ -12,6 +12,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdBookmarksAsync(
@@ -19,6 +20,7 @@ public partial interface IUserItemInteractionsClient
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdCartadditions.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdCartadditions.g.cs
index f57e6fc..299b7a0 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdCartadditions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdCartadditions.g.cs
@@ -12,6 +12,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdCartadditionsAsync(
@@ -19,6 +20,7 @@ public partial interface IUserItemInteractionsClient
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdDetailviews.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdDetailviews.g.cs
index ff03759..0e66b1a 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdDetailviews.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdDetailviews.g.cs
@@ -12,6 +12,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdDetailviewsAsync(
@@ -19,6 +20,7 @@ public partial interface IUserItemInteractionsClient
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdPurchases.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdPurchases.g.cs
index 8f65769..267b09e 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdPurchases.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdPurchases.g.cs
@@ -12,6 +12,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdPurchasesAsync(
@@ -19,6 +20,7 @@ public partial interface IUserItemInteractionsClient
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdRatings.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdRatings.g.cs
index 80533f8..f89857b 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdRatings.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdRatings.g.cs
@@ -12,6 +12,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdRatingsAsync(
@@ -19,6 +20,7 @@ public partial interface IUserItemInteractionsClient
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdViewportions.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdViewportions.g.cs
index 6029bfa..5574161 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdViewportions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.DeleteByDatabaseIdViewportions.g.cs
@@ -12,6 +12,7 @@ public partial interface IUserItemInteractionsClient
         /// <param name="userId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdViewportionsAsync(
@@ -19,6 +20,7 @@ public partial interface IUserItemInteractionsClient
             string userId,
             string itemId,
             string? sessionId = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdBookmarks.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdBookmarks.g.cs
index 5e85b03..739c0af 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdBookmarks.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdBookmarks.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Bookmark>> GetByDatabaseIdItemsByItemIdBookmarksAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdCartadditions.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdCartadditions.g.cs
index 38ec016..0fe4e01 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdCartadditions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdCartadditions.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.CartAddition>> GetByDatabaseIdItemsByItemIdCartadditionsAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdDetailviews.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdDetailviews.g.cs
index 1828c31..91a89a4 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdDetailviews.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdDetailviews.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.DetailView>> GetByDatabaseIdItemsByItemIdDetailviewsAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdPurchases.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdPurchases.g.cs
index 7b287ff..9729fc5 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdPurchases.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdPurchases.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Purchase>> GetByDatabaseIdItemsByItemIdPurchasesAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdRatings.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdRatings.g.cs
index 2b9c844..9cd45ac 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdRatings.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdRatings.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Rating>> GetByDatabaseIdItemsByItemIdRatingsAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdViewportions.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdViewportions.g.cs
index 84b1105..a83d06e 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdViewportions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdItemsByItemIdViewportions.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.ViewPortion>> GetByDatabaseIdItemsByItemIdViewportionsAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdBookmarks.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdBookmarks.g.cs
index 2c2c4d1..c9ac3ac 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdBookmarks.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdBookmarks.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Bookmark>> GetByDatabaseIdUsersByUserIdBookmarksAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdCartadditions.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdCartadditions.g.cs
index cff8880..38ce68b 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdCartadditions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdCartadditions.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.CartAddition>> GetByDatabaseIdUsersByUserIdCartadditionsAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdDetailviews.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdDetailviews.g.cs
index 8cebb92..30268de 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdDetailviews.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdDetailviews.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.DetailView>> GetByDatabaseIdUsersByUserIdDetailviewsAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdPurchases.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdPurchases.g.cs
index 1701452..cf548b1 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdPurchases.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdPurchases.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Purchase>> GetByDatabaseIdUsersByUserIdPurchasesAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdRatings.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdRatings.g.cs
index f137670..e3a5708 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdRatings.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdRatings.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Rating>> GetByDatabaseIdUsersByUserIdRatingsAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdViewportions.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdViewportions.g.cs
index c83eb04..4dc6853 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdViewportions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.GetByDatabaseIdUsersByUserIdViewportions.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserItemInteractionsClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.ViewPortion>> GetByDatabaseIdUsersByUserIdViewportionsAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.g.cs b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.g.cs
index 726b2d1..73a74a7 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserItemInteractionsClient.g.cs
@@ -33,6 +33,11 @@ public partial interface IUserItemInteractionsClient : global::System.IDisposabl
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.CreateByDatabaseIdUsersByUserId.g.cs b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.CreateByDatabaseIdUsersByUserId.g.cs
index 39bc1eb..c402e61 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.CreateByDatabaseIdUsersByUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.CreateByDatabaseIdUsersByUserId.g.cs
@@ -12,6 +12,7 @@ public partial interface IUserPropertiesClient
         /// <param name="userId"></param>
         /// <param name="cascadeCreate"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task CreateByDatabaseIdUsersByUserIdAsync(
@@ -20,6 +21,7 @@ public partial interface IUserPropertiesClient
 
             string request,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.DeleteByDatabaseIdUsersPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.DeleteByDatabaseIdUsersPropertiesByPropertyName.g.cs
index 44c8aff..50b5a62 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.DeleteByDatabaseIdUsersPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.DeleteByDatabaseIdUsersPropertiesByPropertyName.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserPropertiesClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdUsersPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersByUserId.g.cs b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersByUserId.g.cs
index 4c3bab6..62a273f 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersByUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersByUserId.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserPropertiesClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<string> GetByDatabaseIdUsersByUserIdAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersPropertiesByPropertyName.g.cs
index b8d6203..3475d64 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersPropertiesByPropertyName.g.cs
@@ -10,11 +10,13 @@ public partial interface IUserPropertiesClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::Recombee.PropertyInfo> GetByDatabaseIdUsersPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersPropertiesList.g.cs b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersPropertiesList.g.cs
index 55789d2..72f928c 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersPropertiesList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.GetByDatabaseIdUsersPropertiesList.g.cs
@@ -9,10 +9,12 @@ public partial interface IUserPropertiesClient
         /// Gets the list of all the user properties in your database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>> GetByDatabaseIdUsersPropertiesListAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.PutByDatabaseIdUsersPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.PutByDatabaseIdUsersPropertiesByPropertyName.g.cs
index 5cba8a3..47fd441 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.PutByDatabaseIdUsersPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.PutByDatabaseIdUsersPropertiesByPropertyName.g.cs
@@ -11,12 +11,14 @@ public partial interface IUserPropertiesClient
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></param>
         /// <param name="type"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdUsersPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
             global::Recombee.PutUsersPropertiesType type,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.g.cs b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.g.cs
index c7ff915..753fa62 100644
--- a/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUserPropertiesClient.g.cs
@@ -33,6 +33,11 @@ public partial interface IUserPropertiesClient : global::System.IDisposable
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.IUsersClient.DeleteByDatabaseIdUsersByUserId.g.cs b/src/libs/Recombee/Generated/Recombee.IUsersClient.DeleteByDatabaseIdUsersByUserId.g.cs
index 631d92b..a971d63 100644
--- a/src/libs/Recombee/Generated/Recombee.IUsersClient.DeleteByDatabaseIdUsersByUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUsersClient.DeleteByDatabaseIdUsersByUserId.g.cs
@@ -11,11 +11,13 @@ public partial interface IUsersClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task DeleteByDatabaseIdUsersByUserIdAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUsersClient.GetByDatabaseIdUsersList.g.cs b/src/libs/Recombee/Generated/Recombee.IUsersClient.GetByDatabaseIdUsersList.g.cs
index 29b0132..9a1f830 100644
--- a/src/libs/Recombee/Generated/Recombee.IUsersClient.GetByDatabaseIdUsersList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUsersClient.GetByDatabaseIdUsersList.g.cs
@@ -14,6 +14,7 @@ public partial interface IUsersClient
         /// <param name="offset"></param>
         /// <param name="returnProperties"></param>
         /// <param name="includedProperties"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.User>> GetByDatabaseIdUsersListAsync(
@@ -23,6 +24,7 @@ public partial interface IUsersClient
             int? offset = default,
             bool? returnProperties = default,
             global::System.Collections.Generic.IList<string>? includedProperties = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUsersClient.PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserId.g.cs b/src/libs/Recombee/Generated/Recombee.IUsersClient.PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserId.g.cs
index 04a2a51..f2785ed 100644
--- a/src/libs/Recombee/Generated/Recombee.IUsersClient.PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUsersClient.PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserId.g.cs
@@ -15,6 +15,7 @@ public partial interface IUsersClient
         /// <param name="targetUserId"></param>
         /// <param name="sourceUserId"></param>
         /// <param name="cascadeCreate"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdAsync(
@@ -22,6 +23,7 @@ public partial interface IUsersClient
             string targetUserId,
             string sourceUserId,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUsersClient.PutByDatabaseIdUsersByUserId.g.cs b/src/libs/Recombee/Generated/Recombee.IUsersClient.PutByDatabaseIdUsersByUserId.g.cs
index 027c90a..ddde4e6 100644
--- a/src/libs/Recombee/Generated/Recombee.IUsersClient.PutByDatabaseIdUsersByUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUsersClient.PutByDatabaseIdUsersByUserId.g.cs
@@ -10,11 +10,13 @@ public partial interface IUsersClient
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         global::System.Threading.Tasks.Task PutByDatabaseIdUsersByUserIdAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.IUsersClient.g.cs b/src/libs/Recombee/Generated/Recombee.IUsersClient.g.cs
index 8484bf1..78e6e12 100644
--- a/src/libs/Recombee/Generated/Recombee.IUsersClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.IUsersClient.g.cs
@@ -33,6 +33,11 @@ public partial interface IUsersClient : global::System.IDisposable
         /// </summary>
         public bool ReadResponseAsString { get; set; }
 
+        /// <summary>
+        /// Client-wide request defaults such as headers, query parameters, retries, and timeout.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.CreateByDatabaseIdItemsByItemId.g.cs b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.CreateByDatabaseIdItemsByItemId.g.cs
index f735bb8..330b647 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.CreateByDatabaseIdItemsByItemId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.CreateByDatabaseIdItemsByItemId.g.cs
@@ -14,6 +14,7 @@ public partial class ItemPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,6 +50,7 @@ partial void ProcessCreateByDatabaseIdItemsByItemIdResponse(
         /// <param name="itemId"></param>
         /// <param name="cascadeCreate"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdItemsByItemIdAsync(
@@ -57,6 +59,7 @@ partial void ProcessCreateByDatabaseIdItemsByItemIdResponse(
 
             string request,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -76,25 +79,46 @@ partial void ProcessCreateByDatabaseIdItemsByItemIdResponse(
                 securityRequirements: s_CreateByDatabaseIdItemsByItemIdSecurityRequirements,
                 operationName: "CreateByDatabaseIdItemsByItemIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddOptionalParameter("cascadeCreate", cascadeCreate?.ToString().ToLowerInvariant()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddOptionalParameter("cascadeCreate", cascadeCreate?.ToString().ToLowerInvariant()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -104,170 +128,329 @@ partial void ProcessCreateByDatabaseIdItemsByItemIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = global::System.Text.Json.JsonSerializer.Serialize(request, request.GetType(), JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = global::System.Text.Json.JsonSerializer.Serialize(request, request.GetType(), JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdItemsByItemIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId,
-                cascadeCreate: cascadeCreate,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdItemsByItemIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId,
+                    cascadeCreate: cascadeCreate,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdItemsByItemIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdItemsByItemId",
+                                methodName: "CreateByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdItemsByItemId",
+                                methodName: "CreateByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdItemsByItemId",
+                                methodName: "CreateByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdItemsByItemIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdItemsByItemId",
+                                methodName: "CreateByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdItemsByItemId",
+                                methodName: "CreateByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.CreateByDatabaseIdMoreItems.g.cs b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.CreateByDatabaseIdMoreItems.g.cs
index 1d21003..6d85153 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.CreateByDatabaseIdMoreItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.CreateByDatabaseIdMoreItems.g.cs
@@ -14,6 +14,7 @@ public partial class ItemPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -55,12 +56,14 @@ partial void ProcessCreateByDatabaseIdMoreItemsResponseContent(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.UpdateMoreItemsResponse> CreateByDatabaseIdMoreItemsAsync(
             string databaseId,
 
             global::Recombee.UpdateMoreItemsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -78,22 +81,43 @@ partial void ProcessCreateByDatabaseIdMoreItemsResponseContent(
                 securityRequirements: s_CreateByDatabaseIdMoreItemsSecurityRequirements,
                 operationName: "CreateByDatabaseIdMoreItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/more-items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/more-items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,185 +127,344 @@ partial void ProcessCreateByDatabaseIdMoreItemsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdMoreItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdMoreItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdMoreItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdMoreItems",
+                                methodName: "CreateByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdMoreItems",
+                                methodName: "CreateByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdMoreItems",
+                                methodName: "CreateByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdMoreItemsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdMoreItemsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.UpdateMoreItemsResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdMoreItems",
+                                methodName: "CreateByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdMoreItems",
+                                methodName: "CreateByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.UpdateMoreItemsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdMoreItemsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.UpdateMoreItemsResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.UpdateMoreItemsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Update More Items<br/>
@@ -301,12 +484,14 @@ partial void ProcessCreateByDatabaseIdMoreItemsResponseContent(
         /// <param name="changes">
         /// A dictionary where the keys are properties that shall be updated.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.UpdateMoreItemsResponse> CreateByDatabaseIdMoreItemsAsync(
             string databaseId,
             string filter,
             object changes,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.UpdateMoreItemsParameters
@@ -318,6 +503,7 @@ partial void ProcessCreateByDatabaseIdMoreItemsResponseContent(
             return await CreateByDatabaseIdMoreItemsAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.DeleteByDatabaseIdItemsPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.DeleteByDatabaseIdItemsPropertiesByPropertyName.g.cs
index 919eb7c..2c4787d 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.DeleteByDatabaseIdItemsPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.DeleteByDatabaseIdItemsPropertiesByPropertyName.g.cs
@@ -14,6 +14,7 @@ public partial class ItemPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,11 +44,13 @@ partial void ProcessDeleteByDatabaseIdItemsPropertiesByPropertyNameResponse(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdItemsPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -63,22 +66,43 @@ partial void ProcessDeleteByDatabaseIdItemsPropertiesByPropertyNameResponse(
                 securityRequirements: s_DeleteByDatabaseIdItemsPropertiesByPropertyNameSecurityRequirements,
                 operationName: "DeleteByDatabaseIdItemsPropertiesByPropertyNameAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/properties/{propertyName}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/properties/{propertyName}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -88,162 +112,321 @@ partial void ProcessDeleteByDatabaseIdItemsPropertiesByPropertyNameResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdItemsPropertiesByPropertyNameRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                propertyName: propertyName);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdItemsPropertiesByPropertyNameRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    propertyName: propertyName);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdItemsPropertiesByPropertyNameResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdItemsPropertiesByPropertyNameResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsByItemId.g.cs b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsByItemId.g.cs
index 67d83e7..a2d0ce4 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsByItemId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsByItemId.g.cs
@@ -14,6 +14,7 @@ public partial class ItemPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdItemsByItemIdResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<string> GetByDatabaseIdItemsByItemIdAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdItemsByItemIdResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsByItemIdSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsByItemIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,175 +117,334 @@ partial void ProcessGetByDatabaseIdItemsByItemIdResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsByItemIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsByItemIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsByItemIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemId",
+                                methodName: "GetByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemId",
+                                methodName: "GetByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemId",
+                                methodName: "GetByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsByItemIdResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsByItemIdResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return __content;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemId",
+                                methodName: "GetByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemId",
+                                methodName: "GetByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return __content;
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsByItemIdResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return __content;
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return __content;
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsPropertiesByPropertyName.g.cs
index 36caf18..b246e01 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsPropertiesByPropertyName.g.cs
@@ -14,6 +14,7 @@ public partial class ItemPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdItemsPropertiesByPropertyNameResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.PropertyInfo> GetByDatabaseIdItemsPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdItemsPropertiesByPropertyNameResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsPropertiesByPropertyNameSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsPropertiesByPropertyNameAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/properties/{propertyName}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/properties/{propertyName}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdItemsPropertiesByPropertyNameResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsPropertiesByPropertyNameRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                propertyName: propertyName);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsPropertiesByPropertyNameRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    propertyName: propertyName);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsPropertiesByPropertyNameResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsPropertiesByPropertyNameResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsPropertiesByPropertyNameResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.PropertyInfo.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.PropertyInfo.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsPropertiesByPropertyNameResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.PropertyInfo.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.PropertyInfo.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsPropertiesList.g.cs b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsPropertiesList.g.cs
index 274ed23..3ca59dc 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsPropertiesList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.GetByDatabaseIdItemsPropertiesList.g.cs
@@ -14,6 +14,7 @@ public partial class ItemPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -45,10 +46,12 @@ partial void ProcessGetByDatabaseIdItemsPropertiesListResponseContent(
         /// Gets the list of all the item properties in your database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>> GetByDatabaseIdItemsPropertiesListAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -63,22 +66,43 @@ partial void ProcessGetByDatabaseIdItemsPropertiesListResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsPropertiesListSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsPropertiesListAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/properties/list/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/properties/list/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -88,145 +112,304 @@ partial void ProcessGetByDatabaseIdItemsPropertiesListResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsPropertiesListRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsPropertiesListRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsPropertiesListResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 404)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesList",
+                                methodName: "GetByDatabaseIdItemsPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesList",
+                                methodName: "GetByDatabaseIdItemsPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesList",
+                                methodName: "GetByDatabaseIdItemsPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsPropertiesListResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsPropertiesListResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesList",
+                                methodName: "GetByDatabaseIdItemsPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsPropertiesList",
+                                methodName: "GetByDatabaseIdItemsPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsPropertiesListResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.PutByDatabaseIdItemsPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.PutByDatabaseIdItemsPropertiesByPropertyName.g.cs
index 2b7634d..273409d 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.PutByDatabaseIdItemsPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.PutByDatabaseIdItemsPropertiesByPropertyName.g.cs
@@ -14,6 +14,7 @@ public partial class ItemPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -46,12 +47,14 @@ partial void ProcessPutByDatabaseIdItemsPropertiesByPropertyNameResponse(
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></param>
         /// <param name="type"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdItemsPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
             global::Recombee.PutItemsPropertiesType type,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,25 +71,46 @@ partial void ProcessPutByDatabaseIdItemsPropertiesByPropertyNameResponse(
                 securityRequirements: s_PutByDatabaseIdItemsPropertiesByPropertyNameSecurityRequirements,
                 operationName: "PutByDatabaseIdItemsPropertiesByPropertyNameAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/properties/{propertyName}",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddRequiredParameter("type", type.ToValueString()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/properties/{propertyName}",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddRequiredParameter("type", type.ToValueString()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -96,163 +120,322 @@ partial void ProcessPutByDatabaseIdItemsPropertiesByPropertyNameResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdItemsPropertiesByPropertyNameRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                propertyName: propertyName,
-                type: type);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdItemsPropertiesByPropertyNameRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    propertyName: propertyName,
+                    type: type);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdItemsPropertiesByPropertyNameResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessPutByDatabaseIdItemsPropertiesByPropertyNameResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdItemsPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/items/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.g.cs b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.g.cs
index 7c8a808..000c8c6 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemPropertiesClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class ItemPropertiesClient : global::Recombee.IItemPropert
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public ItemPropertiesClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the ItemPropertiesClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 ItemPropertiesClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.ItemsClient.DeleteByDatabaseIdItemsByItemId.g.cs b/src/libs/Recombee/Generated/Recombee.ItemsClient.DeleteByDatabaseIdItemsByItemId.g.cs
index 29368b0..54987dc 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemsClient.DeleteByDatabaseIdItemsByItemId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemsClient.DeleteByDatabaseIdItemsByItemId.g.cs
@@ -14,6 +14,7 @@ public partial class ItemsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -45,11 +46,13 @@ partial void ProcessDeleteByDatabaseIdItemsByItemIdResponse(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdItemsByItemIdAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -65,22 +68,43 @@ partial void ProcessDeleteByDatabaseIdItemsByItemIdResponse(
                 securityRequirements: s_DeleteByDatabaseIdItemsByItemIdSecurityRequirements,
                 operationName: "DeleteByDatabaseIdItemsByItemIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -90,162 +114,321 @@ partial void ProcessDeleteByDatabaseIdItemsByItemIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdItemsByItemIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdItemsByItemIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdItemsByItemIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsByItemId",
+                                methodName: "DeleteByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsByItemId",
+                                methodName: "DeleteByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsByItemId",
+                                methodName: "DeleteByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdItemsByItemIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsByItemId",
+                                methodName: "DeleteByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdItemsByItemId",
+                                methodName: "DeleteByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.ItemsClient.DeleteByDatabaseIdMoreItems.g.cs b/src/libs/Recombee/Generated/Recombee.ItemsClient.DeleteByDatabaseIdMoreItems.g.cs
index 00ffb6d..ab087ad 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemsClient.DeleteByDatabaseIdMoreItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemsClient.DeleteByDatabaseIdMoreItems.g.cs
@@ -14,6 +14,7 @@ public partial class ItemsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,12 +50,14 @@ partial void ProcessDeleteByDatabaseIdMoreItemsResponseContent(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.DeleteMoreItemsResponse> DeleteByDatabaseIdMoreItemsAsync(
             string databaseId,
 
             global::Recombee.DeleteMoreItemsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -72,22 +75,43 @@ partial void ProcessDeleteByDatabaseIdMoreItemsResponseContent(
                 securityRequirements: s_DeleteByDatabaseIdMoreItemsSecurityRequirements,
                 operationName: "DeleteByDatabaseIdMoreItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/more-items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/more-items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -97,152 +121,311 @@ partial void ProcessDeleteByDatabaseIdMoreItemsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdMoreItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdMoreItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdMoreItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdMoreItems",
+                                methodName: "DeleteByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdMoreItems",
+                                methodName: "DeleteByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdMoreItems",
+                                methodName: "DeleteByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessDeleteByDatabaseIdMoreItemsResponseContent(
+                    response: __response);
+                ProcessDeleteByDatabaseIdMoreItemsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.DeleteMoreItemsResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdMoreItems",
+                                methodName: "DeleteByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdMoreItems",
+                                methodName: "DeleteByDatabaseIdMoreItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/more-items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.DeleteMoreItemsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessDeleteByDatabaseIdMoreItemsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.DeleteMoreItemsResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.DeleteMoreItemsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Delete More Items<br/>
@@ -253,11 +436,13 @@ partial void ProcessDeleteByDatabaseIdMoreItemsResponseContent(
         /// <param name="filter">
         /// A [ReQL](https://docs.recombee.com/reql) expression, which returns `true` for the items that shall be updated.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.DeleteMoreItemsResponse> DeleteByDatabaseIdMoreItemsAsync(
             string databaseId,
             string filter,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.DeleteMoreItemsParameters
@@ -268,6 +453,7 @@ partial void ProcessDeleteByDatabaseIdMoreItemsResponseContent(
             return await DeleteByDatabaseIdMoreItemsAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.ItemsClient.GetByDatabaseIdItemsList.g.cs b/src/libs/Recombee/Generated/Recombee.ItemsClient.GetByDatabaseIdItemsList.g.cs
index 067e53e..ecac029 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemsClient.GetByDatabaseIdItemsList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemsClient.GetByDatabaseIdItemsList.g.cs
@@ -14,6 +14,7 @@ public partial class ItemsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -60,6 +61,7 @@ partial void ProcessGetByDatabaseIdItemsListResponseContent(
         /// <param name="offset"></param>
         /// <param name="returnProperties"></param>
         /// <param name="includedProperties"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Item>> GetByDatabaseIdItemsListAsync(
@@ -69,6 +71,7 @@ partial void ProcessGetByDatabaseIdItemsListResponseContent(
             int? offset = default,
             bool? returnProperties = default,
             global::System.Collections.Generic.IList<string>? includedProperties = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -88,29 +91,50 @@ partial void ProcessGetByDatabaseIdItemsListResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsListSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsListAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/list/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddOptionalParameter("filter", filter)
-                .AddOptionalParameter("count", count?.ToString())
-                .AddOptionalParameter("offset", offset?.ToString())
-                .AddOptionalParameter("returnProperties", returnProperties?.ToString().ToLowerInvariant())
-                .AddOptionalParameter("includedProperties", includedProperties, delimiter: ",", explode: false) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/list/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddOptionalParameter("filter", filter)
+                                .AddOptionalParameter("count", count?.ToString())
+                                .AddOptionalParameter("offset", offset?.ToString())
+                                .AddOptionalParameter("returnProperties", returnProperties?.ToString().ToLowerInvariant())
+                                .AddOptionalParameter("includedProperties", includedProperties, delimiter: ",", explode: false) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -120,150 +144,309 @@ partial void ProcessGetByDatabaseIdItemsListResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsListRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                filter: filter,
-                count: count,
-                offset: offset,
-                returnProperties: returnProperties,
-                includedProperties: includedProperties);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsListRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    filter: filter,
+                    count: count,
+                    offset: offset,
+                    returnProperties: returnProperties,
+                    includedProperties: includedProperties);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsListResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 404)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsList",
+                                methodName: "GetByDatabaseIdItemsListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
+                    {
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsList",
+                                methodName: "GetByDatabaseIdItemsListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsList",
+                                methodName: "GetByDatabaseIdItemsListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsListResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsListResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Item>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Item>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsList",
+                                methodName: "GetByDatabaseIdItemsListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsList",
+                                methodName: "GetByDatabaseIdItemsListAsync",
+                                pathTemplate: "$\"/{databaseId}/items/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Item>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Item>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsListResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Item>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Item>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Item>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Item>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.ItemsClient.PutByDatabaseIdItemsByItemId.g.cs b/src/libs/Recombee/Generated/Recombee.ItemsClient.PutByDatabaseIdItemsByItemId.g.cs
index 50bda84..9262882 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemsClient.PutByDatabaseIdItemsByItemId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemsClient.PutByDatabaseIdItemsByItemId.g.cs
@@ -14,6 +14,7 @@ public partial class ItemsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -44,11 +45,13 @@ partial void ProcessPutByDatabaseIdItemsByItemIdResponse(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdItemsByItemIdAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -64,22 +67,43 @@ partial void ProcessPutByDatabaseIdItemsByItemIdResponse(
                 securityRequirements: s_PutByDatabaseIdItemsByItemIdSecurityRequirements,
                 operationName: "PutByDatabaseIdItemsByItemIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -89,162 +113,321 @@ partial void ProcessPutByDatabaseIdItemsByItemIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdItemsByItemIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdItemsByItemIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdItemsByItemIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsByItemId",
+                                methodName: "PutByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsByItemId",
+                                methodName: "PutByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsByItemId",
+                                methodName: "PutByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessPutByDatabaseIdItemsByItemIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsByItemId",
+                                methodName: "PutByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdItemsByItemId",
+                                methodName: "PutByDatabaseIdItemsByItemIdAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.ItemsClient.g.cs b/src/libs/Recombee/Generated/Recombee.ItemsClient.g.cs
index abae4b7..8919ebe 100644
--- a/src/libs/Recombee/Generated/Recombee.ItemsClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.ItemsClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class ItemsClient : global::Recombee.IItemsClient, global:
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public ItemsClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the ItemsClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 ItemsClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.CreateByDatabaseIdBatch.g.cs b/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.CreateByDatabaseIdBatch.g.cs
index 4532b84..65c2119 100644
--- a/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.CreateByDatabaseIdBatch.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.CreateByDatabaseIdBatch.g.cs
@@ -14,6 +14,7 @@ public partial class MiscellaneousClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -45,12 +46,14 @@ partial void ProcessCreateByDatabaseIdBatchResponse(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdBatchAsync(
             string databaseId,
 
             global::Recombee.Batch request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -68,22 +71,43 @@ partial void ProcessCreateByDatabaseIdBatchResponse(
                 securityRequirements: s_CreateByDatabaseIdBatchSecurityRequirements,
                 operationName: "CreateByDatabaseIdBatchAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/batch/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/batch/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,201 +117,360 @@ partial void ProcessCreateByDatabaseIdBatchResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdBatchRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdBatchRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdBatchResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBatch",
+                                methodName: "CreateByDatabaseIdBatchAsync",
+                                pathTemplate: "$\"/{databaseId}/batch/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBatch",
+                                methodName: "CreateByDatabaseIdBatchAsync",
+                                pathTemplate: "$\"/{databaseId}/batch/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBatch",
+                                methodName: "CreateByDatabaseIdBatchAsync",
+                                pathTemplate: "$\"/{databaseId}/batch/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 413)
-            {
-                string? __content_413 = null;
-                global::System.Exception? __exception_413 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdBatchResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_413 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_413 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBatch",
+                                methodName: "CreateByDatabaseIdBatchAsync",
+                                pathTemplate: "$\"/{databaseId}/batch/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_413 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBatch",
+                                methodName: "CreateByDatabaseIdBatchAsync",
+                                pathTemplate: "$\"/{databaseId}/batch/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_413 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_413,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_413,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 413)
+                            {
+                                string? __content_413 = null;
+                                global::System.Exception? __exception_413 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_413 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_413 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_413 = __ex;
+                                }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_413 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_413,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_413,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -303,12 +486,14 @@ partial void ProcessCreateByDatabaseIdBatchResponse(
         /// <param name="distinctRecomms">
         /// Makes all the recommended items for a certain user distinct among multiple recommendation requests in the batch.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdBatchAsync(
             string databaseId,
             global::System.Collections.Generic.IList<object> requests,
             bool? distinctRecomms = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.Batch
@@ -320,6 +505,7 @@ partial void ProcessCreateByDatabaseIdBatchResponse(
             await CreateByDatabaseIdBatchAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.DeleteByDatabaseId.g.cs b/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.DeleteByDatabaseId.g.cs
index 4a28bfd..698c4ae 100644
--- a/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.DeleteByDatabaseId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.DeleteByDatabaseId.g.cs
@@ -14,6 +14,7 @@ public partial class MiscellaneousClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -40,10 +41,12 @@ partial void ProcessDeleteByDatabaseIdResponse(
         /// Completely erases all your data, including items, item properties, series, user database, purchases, ratings, detail views, and bookmarks. Make sure the request is never executed in the production environment! Resetting your database is irreversible.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -58,22 +61,43 @@ partial void ProcessDeleteByDatabaseIdResponse(
                 securityRequirements: s_DeleteByDatabaseIdSecurityRequirements,
                 operationName: "DeleteByDatabaseIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -83,96 +107,255 @@ partial void ProcessDeleteByDatabaseIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId);
 
-            using var __response = await HttpClient.SendAsync(
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
+            {
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
+                {
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseId",
+                                methodName: "DeleteByDatabaseIdAsync",
+                                pathTemplate: "$\"/{databaseId}/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
                 request: __httpRequest,
                 completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
+                    {
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseId",
+                                methodName: "DeleteByDatabaseIdAsync",
+                                pathTemplate: "$\"/{databaseId}/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseId",
+                                methodName: "DeleteByDatabaseIdAsync",
+                                pathTemplate: "$\"/{databaseId}/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                    break;
+                }
 
-                try
+                if (__response == null)
                 {
-                    __response.EnsureSuccessStatusCode();
-
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
-                catch (global::System.Exception __ex)
+
+                using (__response)
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
-            }
-            else
-            {
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseId",
+                                methodName: "DeleteByDatabaseIdAsync",
+                                pathTemplate: "$\"/{databaseId}/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseId",
+                                methodName: "DeleteByDatabaseIdAsync",
+                                pathTemplate: "$\"/{databaseId}/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.GetByDatabaseIdScenarios.g.cs b/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.GetByDatabaseIdScenarios.g.cs
index c36b089..1310390 100644
--- a/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.GetByDatabaseIdScenarios.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.GetByDatabaseIdScenarios.g.cs
@@ -14,6 +14,7 @@ public partial class MiscellaneousClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -45,10 +46,12 @@ partial void ProcessGetByDatabaseIdScenariosResponseContent(
         /// Get all [Scenarios](https://docs.recombee.com/scenarios) of the given database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Scenario>> GetByDatabaseIdScenariosAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -63,22 +66,43 @@ partial void ProcessGetByDatabaseIdScenariosResponseContent(
                 securityRequirements: s_GetByDatabaseIdScenariosSecurityRequirements,
                 operationName: "GetByDatabaseIdScenariosAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/scenarios/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/scenarios/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -88,112 +112,271 @@ partial void ProcessGetByDatabaseIdScenariosResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdScenariosRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId);
-
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdScenariosRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdScenariosResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
+                return __httpRequest;
+            }
 
-            if (ReadResponseAsString)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
+                {
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdScenarios",
+                                methodName: "GetByDatabaseIdScenariosAsync",
+                                pathTemplate: "$\"/{databaseId}/scenarios/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
+                    {
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdScenarios",
+                                methodName: "GetByDatabaseIdScenariosAsync",
+                                pathTemplate: "$\"/{databaseId}/scenarios/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdScenariosResponseContent(
-                    httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdScenarios",
+                                methodName: "GetByDatabaseIdScenariosAsync",
+                                pathTemplate: "$\"/{databaseId}/scenarios/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Scenario>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Scenario>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
-            }
-            else
-            {
-                try
+
+                using (__response)
                 {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Scenario>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Scenario>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessGetByDatabaseIdScenariosResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
+                {
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdScenarios",
+                                methodName: "GetByDatabaseIdScenariosAsync",
+                                pathTemplate: "$\"/{databaseId}/scenarios/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdScenarios",
+                                methodName: "GetByDatabaseIdScenariosAsync",
+                                pathTemplate: "$\"/{databaseId}/scenarios/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdScenariosResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Scenario>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Scenario>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Scenario>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Scenario>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.g.cs b/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.g.cs
index 026f683..0934f59 100644
--- a/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.MiscellaneousClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class MiscellaneousClient : global::Recombee.IMiscellaneou
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public MiscellaneousClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the MiscellaneousClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 MiscellaneousClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.OptionsSupport.g.cs b/src/libs/Recombee/Generated/Recombee.OptionsSupport.g.cs
new file mode 100644
index 0000000..c56c70a
--- /dev/null
+++ b/src/libs/Recombee/Generated/Recombee.OptionsSupport.g.cs
@@ -0,0 +1,460 @@
+
+#nullable enable
+
+namespace Recombee
+{
+    /// <summary>
+    /// Global defaults applied to generated SDK requests.
+    /// </summary>
+    public sealed class AutoSDKClientOptions
+    {
+        /// <summary>
+        /// Additional headers applied to every request after generated headers are set.
+        /// Entries with the same key overwrite earlier header values.
+        /// </summary>
+        public global::System.Collections.Generic.Dictionary<string, string> Headers { get; } =
+            new global::System.Collections.Generic.Dictionary<string, string>(global::System.StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// Additional query parameters appended to every request.
+        /// Request-level entries with the same key are appended after client defaults.
+        /// </summary>
+        public global::System.Collections.Generic.Dictionary<string, string> QueryParameters { get; } =
+            new global::System.Collections.Generic.Dictionary<string, string>(global::System.StringComparer.Ordinal);
+
+        /// <summary>
+        /// Optional timeout applied to the full request execution.
+        /// </summary>
+        public global::System.TimeSpan? Timeout { get; set; }
+
+        /// <summary>
+        /// Default retry behavior for generated HTTP requests.
+        /// </summary>
+        public global::Recombee.AutoSDKRetryOptions Retry { get; set; } = new global::Recombee.AutoSDKRetryOptions();
+
+        /// <summary>
+        /// Overrides the client-wide response buffering mode when set.
+        /// </summary>
+        public bool? ReadResponseAsString { get; set; }
+
+        /// <summary>
+        /// Reusable hooks invoked for every generated SDK request.
+        /// </summary>
+        public global::System.Collections.Generic.List<global::Recombee.IAutoSDKHook> Hooks { get; } =
+            new global::System.Collections.Generic.List<global::Recombee.IAutoSDKHook>();
+
+        /// <summary>
+        /// Registers a hook for all requests issued by this client.
+        /// </summary>
+        /// <param name="hook"></param>
+        /// <returns>The current options instance.</returns>
+        public global::Recombee.AutoSDKClientOptions AddHook(
+            global::Recombee.IAutoSDKHook hook)
+        {
+            Hooks.Add(hook ?? throw new global::System.ArgumentNullException(nameof(hook)));
+            return this;
+        }
+    }
+
+    /// <summary>
+    /// Per-request overrides applied on top of <see cref="AutoSDKClientOptions"/>.
+    /// </summary>
+    public sealed class AutoSDKRequestOptions
+    {
+        /// <summary>
+        /// Additional headers applied after generated and client-level headers.
+        /// </summary>
+        public global::System.Collections.Generic.Dictionary<string, string> Headers { get; } =
+            new global::System.Collections.Generic.Dictionary<string, string>(global::System.StringComparer.OrdinalIgnoreCase);
+
+        /// <summary>
+        /// Additional query parameters appended after generated and client-level query parameters.
+        /// </summary>
+        public global::System.Collections.Generic.Dictionary<string, string> QueryParameters { get; } =
+            new global::System.Collections.Generic.Dictionary<string, string>(global::System.StringComparer.Ordinal);
+
+        /// <summary>
+        /// Optional timeout override for this request.
+        /// </summary>
+        public global::System.TimeSpan? Timeout { get; set; }
+
+        /// <summary>
+        /// Optional retry override for this request.
+        /// </summary>
+        public global::Recombee.AutoSDKRetryOptions? Retry { get; set; }
+
+        /// <summary>
+        /// Overrides response buffering for this request when set.
+        /// </summary>
+        public bool? ReadResponseAsString { get; set; }
+    }
+
+    /// <summary>
+    /// Retry settings for generated HTTP requests.
+    /// </summary>
+    public sealed class AutoSDKRetryOptions
+    {
+        /// <summary>
+        /// Total number of attempts, including the initial request.
+        /// Values less than 1 are normalized to 1.
+        /// </summary>
+        public int MaxAttempts { get; set; } = 1;
+
+        /// <summary>
+        /// Optional fixed delay between retry attempts.
+        /// </summary>
+        public global::System.TimeSpan? Delay { get; set; }
+    }
+
+    /// <summary>
+    /// Runtime hook interface for generated SDK lifecycle events.
+    /// </summary>
+    public interface IAutoSDKHook
+    {
+        /// <summary>
+        /// Runs before a request is sent.
+        /// </summary>
+        /// <param name="context"></param>
+        global::System.Threading.Tasks.Task OnBeforeRequestAsync(
+            global::Recombee.AutoSDKHookContext context);
+
+        /// <summary>
+        /// Runs after a successful HTTP response is received.
+        /// </summary>
+        /// <param name="context"></param>
+        global::System.Threading.Tasks.Task OnAfterSuccessAsync(
+            global::Recombee.AutoSDKHookContext context);
+
+        /// <summary>
+        /// Runs after an error response or transport failure is observed.
+        /// </summary>
+        /// <param name="context"></param>
+        global::System.Threading.Tasks.Task OnAfterErrorAsync(
+            global::Recombee.AutoSDKHookContext context);
+    }
+
+    /// <summary>
+    /// Convenience base type for request hooks with no-op defaults.
+    /// </summary>
+    public abstract class AutoSDKHook : global::Recombee.IAutoSDKHook
+    {
+        /// <inheritdoc />
+        public virtual global::System.Threading.Tasks.Task OnBeforeRequestAsync(
+            global::Recombee.AutoSDKHookContext context)
+        {
+            return global::System.Threading.Tasks.Task.CompletedTask;
+        }
+
+        /// <inheritdoc />
+        public virtual global::System.Threading.Tasks.Task OnAfterSuccessAsync(
+            global::Recombee.AutoSDKHookContext context)
+        {
+            return global::System.Threading.Tasks.Task.CompletedTask;
+        }
+
+        /// <inheritdoc />
+        public virtual global::System.Threading.Tasks.Task OnAfterErrorAsync(
+            global::Recombee.AutoSDKHookContext context)
+        {
+            return global::System.Threading.Tasks.Task.CompletedTask;
+        }
+    }
+
+    /// <summary>
+    /// Runtime metadata passed to generated SDK hooks.
+    /// </summary>
+    public sealed class AutoSDKHookContext
+    {
+        /// <summary>
+        /// The source OpenAPI operation id or generated fallback id.
+        /// </summary>
+        public string OperationId { get; set; } = string.Empty;
+
+        /// <summary>
+        /// The generated C# method name.
+        /// </summary>
+        public string MethodName { get; set; } = string.Empty;
+
+        /// <summary>
+        /// The OpenAPI path template for the operation.
+        /// </summary>
+        public string PathTemplate { get; set; } = string.Empty;
+
+        /// <summary>
+        /// The HTTP method used for the request.
+        /// </summary>
+        public string HttpMethod { get; set; } = string.Empty;
+
+        /// <summary>
+        /// The client's resolved base URI.
+        /// </summary>
+        public global::System.Uri? BaseUri { get; set; }
+
+        /// <summary>
+        /// The outgoing HTTP request for the current attempt.
+        /// </summary>
+        public global::System.Net.Http.HttpRequestMessage Request { get; set; } = null!;
+
+        /// <summary>
+        /// The HTTP response when one was received.
+        /// </summary>
+        public global::System.Net.Http.HttpResponseMessage? Response { get; set; }
+
+        /// <summary>
+        /// The transport or processing exception when one was observed.
+        /// </summary>
+        public global::System.Exception? Exception { get; set; }
+
+        /// <summary>
+        /// The client-wide runtime options.
+        /// </summary>
+        public global::Recombee.AutoSDKClientOptions ClientOptions { get; set; } = null!;
+
+        /// <summary>
+        /// The per-request runtime options.
+        /// </summary>
+        public global::Recombee.AutoSDKRequestOptions? RequestOptions { get; set; }
+
+        /// <summary>
+        /// The current attempt number, starting at 1.
+        /// </summary>
+        public int Attempt { get; set; }
+
+        /// <summary>
+        /// The total number of attempts allowed for this request.
+        /// </summary>
+        public int MaxAttempts { get; set; }
+
+        /// <summary>
+        /// Indicates whether the generated client will retry after this hook invocation.
+        /// </summary>
+        public bool WillRetry { get; set; }
+
+        /// <summary>
+        /// The effective cancellation token for the current request attempt.
+        /// </summary>
+        public global::System.Threading.CancellationToken CancellationToken { get; set; }
+    }
+
+    internal static class AutoSDKRequestOptionsSupport
+    {
+        internal static global::Recombee.AutoSDKHookContext CreateHookContext(
+            string operationId,
+            string methodName,
+            string pathTemplate,
+            string httpMethod,
+            global::System.Uri? baseUri,
+            global::System.Net.Http.HttpRequestMessage request,
+            global::System.Net.Http.HttpResponseMessage? response,
+            global::System.Exception? exception,
+            global::Recombee.AutoSDKClientOptions clientOptions,
+            global::Recombee.AutoSDKRequestOptions? requestOptions,
+            int attempt,
+            int maxAttempts,
+            bool willRetry,
+            global::System.Threading.CancellationToken cancellationToken)
+        {
+            return new global::Recombee.AutoSDKHookContext
+            {
+                OperationId = operationId ?? string.Empty,
+                MethodName = methodName ?? string.Empty,
+                PathTemplate = pathTemplate ?? string.Empty,
+                HttpMethod = httpMethod ?? string.Empty,
+                BaseUri = baseUri,
+                Request = request,
+                Response = response,
+                Exception = exception,
+                ClientOptions = clientOptions,
+                RequestOptions = requestOptions,
+                Attempt = attempt,
+                MaxAttempts = maxAttempts,
+                WillRetry = willRetry,
+                CancellationToken = cancellationToken,
+            };
+        }
+
+        internal static global::System.Threading.Tasks.Task OnBeforeRequestAsync(
+            global::Recombee.AutoSDKClientOptions clientOptions,
+            global::Recombee.AutoSDKHookContext context)
+        {
+            return InvokeHooksAsync(clientOptions, static (hook, hookContext) => hook.OnBeforeRequestAsync(hookContext), context);
+        }
+
+        internal static global::System.Threading.Tasks.Task OnAfterSuccessAsync(
+            global::Recombee.AutoSDKClientOptions clientOptions,
+            global::Recombee.AutoSDKHookContext context)
+        {
+            return InvokeHooksAsync(clientOptions, static (hook, hookContext) => hook.OnAfterSuccessAsync(hookContext), context);
+        }
+
+        internal static global::System.Threading.Tasks.Task OnAfterErrorAsync(
+            global::Recombee.AutoSDKClientOptions clientOptions,
+            global::Recombee.AutoSDKHookContext context)
+        {
+            return InvokeHooksAsync(clientOptions, static (hook, hookContext) => hook.OnAfterErrorAsync(hookContext), context);
+        }
+
+        internal static bool GetReadResponseAsString(
+            global::Recombee.AutoSDKClientOptions clientOptions,
+            global::Recombee.AutoSDKRequestOptions? requestOptions,
+            bool fallbackValue)
+        {
+            return requestOptions?.ReadResponseAsString ??
+                   clientOptions.ReadResponseAsString ??
+                   fallbackValue;
+        }
+
+        internal static global::System.Threading.CancellationTokenSource? CreateTimeoutCancellationTokenSource(
+            global::Recombee.AutoSDKClientOptions clientOptions,
+            global::Recombee.AutoSDKRequestOptions? requestOptions,
+            global::System.Threading.CancellationToken cancellationToken)
+        {
+            var timeout = requestOptions?.Timeout ?? clientOptions.Timeout;
+            if (!timeout.HasValue || timeout.Value <= global::System.TimeSpan.Zero)
+            {
+                return null;
+            }
+
+            var cancellationTokenSource = global::System.Threading.CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
+            cancellationTokenSource.CancelAfter(timeout.Value);
+            return cancellationTokenSource;
+        }
+
+        internal static int GetMaxAttempts(
+            global::Recombee.AutoSDKClientOptions clientOptions,
+            global::Recombee.AutoSDKRequestOptions? requestOptions,
+            bool supportsRetry)
+        {
+            if (!supportsRetry)
+            {
+                return 1;
+            }
+
+            var maxAttempts = requestOptions?.Retry?.MaxAttempts ??
+                              clientOptions.Retry?.MaxAttempts ??
+                              1;
+            return maxAttempts < 1 ? 1 : maxAttempts;
+        }
+
+        internal static async global::System.Threading.Tasks.Task DelayBeforeRetryAsync(
+            global::Recombee.AutoSDKClientOptions clientOptions,
+            global::Recombee.AutoSDKRequestOptions? requestOptions,
+            global::System.Threading.CancellationToken cancellationToken)
+        {
+            var delay = requestOptions?.Retry?.Delay ??
+                        clientOptions.Retry?.Delay;
+            if (!delay.HasValue || delay.Value <= global::System.TimeSpan.Zero)
+            {
+                return;
+            }
+
+            await global::System.Threading.Tasks.Task.Delay(delay.Value, cancellationToken).ConfigureAwait(false);
+        }
+
+        internal static bool ShouldRetryStatusCode(
+            global::System.Net.HttpStatusCode statusCode)
+        {
+            return (int)statusCode switch
+            {
+                408 => true,
+                429 => true,
+                500 => true,
+                502 => true,
+                503 => true,
+                504 => true,
+                _ => false,
+            };
+        }
+
+        internal static string AppendQueryParameters(
+            string path,
+            global::System.Collections.Generic.Dictionary<string, string> clientParameters,
+            global::System.Collections.Generic.Dictionary<string, string>? requestParameters)
+        {
+            var hasClientParameters = clientParameters != null && clientParameters.Count > 0;
+            var hasRequestParameters = requestParameters != null && requestParameters.Count > 0;
+            if (!hasClientParameters && !hasRequestParameters)
+            {
+                return path;
+            }
+
+            var builder = new global::System.Text.StringBuilder(path ?? string.Empty);
+            var hasQuery = builder.ToString().Contains("?", global::System.StringComparison.Ordinal);
+            AppendParameters(builder, clientParameters, ref hasQuery);
+            AppendParameters(builder, requestParameters, ref hasQuery);
+            return builder.ToString();
+        }
+
+        internal static void ApplyHeaders(
+            global::System.Net.Http.HttpRequestMessage request,
+            global::System.Collections.Generic.Dictionary<string, string> clientHeaders,
+            global::System.Collections.Generic.Dictionary<string, string>? requestHeaders)
+        {
+            ApplyHeadersCore(request, clientHeaders);
+            ApplyHeadersCore(request, requestHeaders);
+        }
+
+        private static void AppendParameters(
+            global::System.Text.StringBuilder builder,
+            global::System.Collections.Generic.Dictionary<string, string>? parameters,
+            ref bool hasQuery)
+        {
+            if (parameters == null || parameters.Count == 0)
+            {
+                return;
+            }
+
+            foreach (var parameter in parameters)
+            {
+                builder.Append(hasQuery ? '&' : '?');
+                builder.Append(global::System.Uri.EscapeDataString(parameter.Key));
+                builder.Append('=');
+                builder.Append(global::System.Uri.EscapeDataString(parameter.Value ?? string.Empty));
+                hasQuery = true;
+            }
+        }
+
+        private static void ApplyHeadersCore(
+            global::System.Net.Http.HttpRequestMessage request,
+            global::System.Collections.Generic.Dictionary<string, string>? headers)
+        {
+            if (headers == null || headers.Count == 0)
+            {
+                return;
+            }
+
+            foreach (var header in headers)
+            {
+                request.Headers.Remove(header.Key);
+                request.Content?.Headers.Remove(header.Key);
+
+                if (!request.Headers.TryAddWithoutValidation(header.Key, header.Value ?? string.Empty) &&
+                    request.Content != null)
+                {
+                    request.Content.Headers.TryAddWithoutValidation(header.Key, header.Value ?? string.Empty);
+                }
+            }
+        }
+
+        private static async global::System.Threading.Tasks.Task InvokeHooksAsync(
+            global::Recombee.AutoSDKClientOptions clientOptions,
+            global::System.Func<global::Recombee.IAutoSDKHook, global::Recombee.AutoSDKHookContext, global::System.Threading.Tasks.Task> callback,
+            global::Recombee.AutoSDKHookContext context)
+        {
+            if (clientOptions.Hooks == null || clientOptions.Hooks.Count == 0)
+            {
+                return;
+            }
+
+            foreach (var hook in clientOptions.Hooks)
+            {
+                if (hook == null)
+                {
+                    continue;
+                }
+
+                await callback(hook, context).ConfigureAwait(false);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.PathBuilder.g.cs b/src/libs/Recombee/Generated/Recombee.PathBuilder.g.cs
index 61c5557..bf2f5fb 100644
--- a/src/libs/Recombee/Generated/Recombee.PathBuilder.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.PathBuilder.g.cs
@@ -275,6 +275,11 @@ public class EndPointAuthorization
         /// </summary>
         public string Type { get; set; } = string.Empty;
 
+        /// <summary>
+        /// 
+        /// </summary>
+        public string SchemeId { get; set; } = string.Empty;
+
         /// <summary>
         /// 
         /// </summary>
diff --git a/src/libs/Recombee/Generated/Recombee.RecombeeClient.Authorizations.Bearer.g.cs b/src/libs/Recombee/Generated/Recombee.RecombeeClient.Authorizations.Bearer.g.cs
index 1e2ba39..cacadfd 100644
--- a/src/libs/Recombee/Generated/Recombee.RecombeeClient.Authorizations.Bearer.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecombeeClient.Authorizations.Bearer.g.cs
@@ -25,6 +25,7 @@ public void AuthorizeUsingBearer(
             Authorizations.Add(new global::Recombee.EndPointAuthorization
             {
                 Type = "Http",
+                SchemeId = "HttpBearer",
                 Location = "Header",
                 Name = "Bearer",
                 Value = apiKey,
diff --git a/src/libs/Recombee/Generated/Recombee.RecombeeClient.g.cs b/src/libs/Recombee/Generated/Recombee.RecombeeClient.g.cs
index 32b32af..75f62c2 100644
--- a/src/libs/Recombee/Generated/Recombee.RecombeeClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecombeeClient.g.cs
@@ -33,6 +33,9 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -42,7 +45,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public ItemPropertiesClient ItemProperties => new ItemPropertiesClient(HttpClient, authorizations: Authorizations)
+        public ItemPropertiesClient ItemProperties => new ItemPropertiesClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -51,7 +54,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public ItemsClient Items => new ItemsClient(HttpClient, authorizations: Authorizations)
+        public ItemsClient Items => new ItemsClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -60,7 +63,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public MiscellaneousClient Miscellaneous => new MiscellaneousClient(HttpClient, authorizations: Authorizations)
+        public MiscellaneousClient Miscellaneous => new MiscellaneousClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -69,7 +72,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public RecommendationsClient Recommendations => new RecommendationsClient(HttpClient, authorizations: Authorizations)
+        public RecommendationsClient Recommendations => new RecommendationsClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -78,7 +81,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public SearchClient Search => new SearchClient(HttpClient, authorizations: Authorizations)
+        public SearchClient Search => new SearchClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -87,7 +90,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public SegmentationsDefinitionClient SegmentationsDefinition => new SegmentationsDefinitionClient(HttpClient, authorizations: Authorizations)
+        public SegmentationsDefinitionClient SegmentationsDefinition => new SegmentationsDefinitionClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -96,7 +99,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public SeriesClient Series => new SeriesClient(HttpClient, authorizations: Authorizations)
+        public SeriesClient Series => new SeriesClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -105,7 +108,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public UserItemInteractionsClient UserItemInteractions => new UserItemInteractionsClient(HttpClient, authorizations: Authorizations)
+        public UserItemInteractionsClient UserItemInteractions => new UserItemInteractionsClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -114,7 +117,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public UserPropertiesClient UserProperties => new UserPropertiesClient(HttpClient, authorizations: Authorizations)
+        public UserPropertiesClient UserProperties => new UserPropertiesClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -123,7 +126,7 @@ public sealed partial class RecombeeClient : global::Recombee.IRecombeeClient, g
         /// <summary>
         /// 
         /// </summary>
-        public UsersClient Users => new UsersClient(HttpClient, authorizations: Authorizations)
+        public UsersClient Users => new UsersClient(HttpClient, authorizations: Authorizations, options: Options)
         {
             ReadResponseAsString = ReadResponseAsString,
             JsonSerializerContext = JsonSerializerContext,
@@ -142,11 +145,37 @@ public RecombeeClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the RecombeeClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 RecombeeClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsComposite.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsComposite.g.cs
index 2ffeb94..345668b 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsComposite.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsComposite.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -65,12 +66,14 @@ partial void ProcessCreateByDatabaseIdRecommsCompositeResponseContent(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.CompositeRecommendationResponse> CreateByDatabaseIdRecommsCompositeAsync(
             string databaseId,
 
             global::Recombee.CompositeRecommendationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -88,22 +91,43 @@ partial void ProcessCreateByDatabaseIdRecommsCompositeResponseContent(
                 securityRequirements: s_CreateByDatabaseIdRecommsCompositeSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsCompositeAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/composite/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/composite/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -113,185 +137,344 @@ partial void ProcessCreateByDatabaseIdRecommsCompositeResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsCompositeRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsCompositeRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsCompositeResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsComposite",
+                                methodName: "CreateByDatabaseIdRecommsCompositeAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/composite/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsComposite",
+                                methodName: "CreateByDatabaseIdRecommsCompositeAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/composite/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsComposite",
+                                methodName: "CreateByDatabaseIdRecommsCompositeAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/composite/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsCompositeResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsCompositeResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.CompositeRecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsComposite",
+                                methodName: "CreateByDatabaseIdRecommsCompositeAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/composite/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsComposite",
+                                methodName: "CreateByDatabaseIdRecommsCompositeAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/composite/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.CompositeRecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsCompositeResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.CompositeRecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.CompositeRecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Composite Recommendation<br/>
@@ -345,6 +528,7 @@ partial void ProcessCreateByDatabaseIdRecommsCompositeResponseContent(
         /// <param name="expertSettings">
         /// Dictionary of custom options.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.CompositeRecommendationResponse> CreateByDatabaseIdRecommsCompositeAsync(
@@ -359,6 +543,7 @@ partial void ProcessCreateByDatabaseIdRecommsCompositeResponseContent(
             object? sourceSettings = default,
             object? resultSettings = default,
             object? expertSettings = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.CompositeRecommendationParameters
@@ -378,6 +563,7 @@ partial void ProcessCreateByDatabaseIdRecommsCompositeResponseContent(
             return await CreateByDatabaseIdRecommsCompositeAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItemSegments.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItemSegments.g.cs
index db512c3..74bbed2 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItemSegments.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItemSegments.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -55,12 +56,14 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponseCon
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync(
             string databaseId,
 
             global::Recombee.RecommendItemSegmentsToItemSegmentParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -78,22 +81,43 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponseCon
                 securityRequirements: s_CreateByDatabaseIdRecommsItemSegmentsItemSegmentsSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/item-segments/item-segments/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/item-segments/item-segments/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,185 +127,344 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponseCon
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsItemSegmentsItemSegmentsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsItemSegmentsItemSegmentsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Recommend Item Segments to Item Segment<br/>
@@ -372,6 +555,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponseCon
         /// }<br/>
         /// ```
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync(
@@ -387,6 +571,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponseCon
             object? expertSettings = default,
             bool? returnAbGroup = default,
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RecommendItemSegmentsToItemSegmentParameters
@@ -407,6 +592,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemSegmentsResponseCon
             return await CreateByDatabaseIdRecommsItemSegmentsItemSegmentsAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItems.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItems.g.cs
index 8283da5..2be93ac 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemSegmentsItems.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -55,12 +56,14 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponseContent(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemSegmentsItemsAsync(
             string databaseId,
 
             global::Recombee.RecommendItemsToItemSegmentParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -78,22 +81,43 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponseContent(
                 securityRequirements: s_CreateByDatabaseIdRecommsItemSegmentsItemsSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsItemSegmentsItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/item-segments/items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/item-segments/items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,185 +127,344 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsItemSegmentsItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsItemSegmentsItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItems",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItems",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItems",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItems",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemSegmentsItems",
+                                methodName: "CreateByDatabaseIdRecommsItemSegmentsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/item-segments/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Recommend Items to Item Segment<br/>
@@ -444,6 +627,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponseContent(
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemSegmentsItemsAsync(
@@ -464,6 +648,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponseContent(
             double? rotationTime = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RecommendItemsToItemSegmentParameters
@@ -489,6 +674,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemSegmentsItemsResponseContent(
             return await CreateByDatabaseIdRecommsItemSegmentsItemsAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItemSegments.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItemSegments.g.cs
index c825549..0710b60 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItemSegments.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItemSegments.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -59,6 +60,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponseCo
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync(
@@ -66,6 +68,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponseCo
             string itemId,
 
             global::Recombee.RecommendItemSegmentsToItemParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -84,22 +87,43 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponseCo
                 securityRequirements: s_CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/items/{itemId}/item-segments/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/items/{itemId}/item-segments/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -109,186 +133,345 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponseCo
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Recommend Item Segments to Item<br/>
@@ -378,6 +561,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponseCo
         /// }<br/>
         /// ```
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdItemSegmentsAsync(
@@ -393,6 +577,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponseCo
             object? expertSettings = default,
             bool? returnAbGroup = default,
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RecommendItemSegmentsToItemParameters
@@ -413,6 +598,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemSegmentsResponseCo
                 databaseId: databaseId,
                 itemId: itemId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItems.g.cs
index 85a5a2e..0d02035 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdItems.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -56,6 +57,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponseContent(
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdItemsAsync(
@@ -63,6 +65,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponseContent(
             string itemId,
 
             global::Recombee.RecommendItemsToItemParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -81,22 +84,43 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponseContent(
                 securityRequirements: s_CreateByDatabaseIdRecommsItemsByItemIdItemsSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsItemsByItemIdItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/items/{itemId}/items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/items/{itemId}/items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -106,186 +130,345 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsItemsByItemIdItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsItemsByItemIdItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItems",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItems",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItems",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItems",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdItems",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Recommend Items to Item<br/>
@@ -453,6 +636,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponseContent(
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdItemsAsync(
@@ -475,6 +659,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponseContent(
             double? rotationTime = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RecommendItemsToItemParameters
@@ -502,6 +687,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdItemsResponseContent(
                 databaseId: databaseId,
                 itemId: itemId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdUsers.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdUsers.g.cs
index 4eec7f6..e6e02e5 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdUsers.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsItemsByItemIdUsers.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -53,6 +54,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponseContent(
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdUsersAsync(
@@ -60,6 +62,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponseContent(
             string itemId,
 
             global::Recombee.RecommendUsersToItemParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -78,22 +81,43 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponseContent(
                 securityRequirements: s_CreateByDatabaseIdRecommsItemsByItemIdUsersSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsItemsByItemIdUsersAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/items/{itemId}/users/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/items/{itemId}/users/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,186 +127,345 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsItemsByItemIdUsersRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsItemsByItemIdUsersRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsItemsByItemIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsItemsByItemIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/items/{itemId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Recommend Users to Item<br/>
@@ -414,6 +597,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponseContent(
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsItemsByItemIdUsersAsync(
@@ -431,6 +615,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponseContent(
             double? diversity = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RecommendUsersToItemParameters
@@ -453,6 +638,7 @@ partial void ProcessCreateByDatabaseIdRecommsItemsByItemIdUsersResponseContent(
                 databaseId: databaseId,
                 itemId: itemId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsNextItemsByRecommId.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsNextItemsByRecommId.g.cs
index 694541f..c16f893 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsNextItemsByRecommId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsNextItemsByRecommId.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -62,6 +63,7 @@ partial void ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponseContent(
         /// <param name="databaseId"></param>
         /// <param name="recommId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsNextItemsByRecommIdAsync(
@@ -69,6 +71,7 @@ partial void ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponseContent(
             string recommId,
 
             global::Recombee.RecommendNextItemsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -87,22 +90,43 @@ partial void ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponseContent(
                 securityRequirements: s_CreateByDatabaseIdRecommsNextItemsByRecommIdSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsNextItemsByRecommIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/next/items/{recommId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/next/items/{recommId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -112,186 +136,345 @@ partial void ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsNextItemsByRecommIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                recommId: recommId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsNextItemsByRecommIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    recommId: recommId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsNextItemsByRecommId",
+                                methodName: "CreateByDatabaseIdRecommsNextItemsByRecommIdAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/next/items/{recommId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsNextItemsByRecommId",
+                                methodName: "CreateByDatabaseIdRecommsNextItemsByRecommIdAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/next/items/{recommId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsNextItemsByRecommId",
+                                methodName: "CreateByDatabaseIdRecommsNextItemsByRecommIdAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/next/items/{recommId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsNextItemsByRecommId",
+                                methodName: "CreateByDatabaseIdRecommsNextItemsByRecommIdAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/next/items/{recommId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsNextItemsByRecommId",
+                                methodName: "CreateByDatabaseIdRecommsNextItemsByRecommIdAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/next/items/{recommId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Recommend Next Items<br/>
@@ -313,12 +496,14 @@ partial void ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponseContent(
         /// <param name="count">
         /// Number of items to be recommended
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsNextItemsByRecommIdAsync(
             string databaseId,
             string recommId,
             int count,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RecommendNextItemsParameters
@@ -330,6 +515,7 @@ partial void ProcessCreateByDatabaseIdRecommsNextItemsByRecommIdResponseContent(
                 databaseId: databaseId,
                 recommId: recommId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItemSegments.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItemSegments.g.cs
index 6651ec6..86459af 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItemSegments.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItemSegments.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -59,6 +60,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponseCo
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync(
@@ -66,6 +68,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponseCo
             string userId,
 
             global::Recombee.RecommendItemSegmentsToUserParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -84,22 +87,43 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponseCo
                 securityRequirements: s_CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/users/{userId}/item-segments/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/users/{userId}/item-segments/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -109,186 +133,345 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponseCo
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Recommend Item Segments to User<br/>
@@ -363,6 +546,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponseCo
         /// }<br/>
         /// ```
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdItemSegmentsAsync(
@@ -377,6 +561,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponseCo
             object? expertSettings = default,
             bool? returnAbGroup = default,
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RecommendItemSegmentsToUserParameters
@@ -396,6 +581,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemSegmentsResponseCo
                 databaseId: databaseId,
                 userId: userId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItems.g.cs
index e7f23f2..71646fb 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdItems.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -57,6 +58,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponseContent(
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdItemsAsync(
@@ -64,6 +66,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponseContent(
             string userId,
 
             global::Recombee.RecommendItemsToUserParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -82,22 +85,43 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponseContent(
                 securityRequirements: s_CreateByDatabaseIdRecommsUsersByUserIdItemsSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsUsersByUserIdItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/users/{userId}/items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/users/{userId}/items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -107,186 +131,345 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsUsersByUserIdItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsUsersByUserIdItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Recommend Items to User<br/>
@@ -434,6 +617,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponseContent(
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdItemsAsync(
@@ -454,6 +638,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponseContent(
             double? rotationTime = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RecommendItemsToUserParameters
@@ -479,6 +664,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdItemsResponseContent(
                 databaseId: databaseId,
                 userId: userId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdUsers.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdUsers.g.cs
index 46f276b..fad0724 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdUsers.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.CreateByDatabaseIdRecommsUsersByUserIdUsers.g.cs
@@ -14,6 +14,7 @@ public partial class RecommendationsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -53,6 +54,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponseContent(
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdUsersAsync(
@@ -60,6 +62,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponseContent(
             string userId,
 
             global::Recombee.RecommendUsersToUserParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -78,22 +81,43 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponseContent(
                 securityRequirements: s_CreateByDatabaseIdRecommsUsersByUserIdUsersSecurityRequirements,
                 operationName: "CreateByDatabaseIdRecommsUsersByUserIdUsersAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/recomms/users/{userId}/users/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/recomms/users/{userId}/users/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,186 +127,345 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRecommsUsersByUserIdUsersRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRecommsUsersByUserIdUsersRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRecommsUsersByUserIdUsers",
+                                methodName: "CreateByDatabaseIdRecommsUsersByUserIdUsersAsync",
+                                pathTemplate: "$\"/{databaseId}/recomms/users/{userId}/users/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.RecommendationResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.RecommendationResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Recommend Users to User<br/>
@@ -420,6 +603,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponseContent(
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.RecommendationResponse> CreateByDatabaseIdRecommsUsersByUserIdUsersAsync(
@@ -440,6 +624,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponseContent(
             double? rotationTime = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RecommendUsersToUserParameters
@@ -465,6 +650,7 @@ partial void ProcessCreateByDatabaseIdRecommsUsersByUserIdUsersResponseContent(
                 databaseId: databaseId,
                 userId: userId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.g.cs b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.g.cs
index 8896a30..b182275 100644
--- a/src/libs/Recombee/Generated/Recombee.RecommendationsClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.RecommendationsClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class RecommendationsClient : global::Recombee.IRecommenda
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public RecommendationsClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the RecommendationsClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 RecommendationsClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSearchUsersByUserIdItemSegments.g.cs b/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSearchUsersByUserIdItemSegments.g.cs
index 42b2c90..4301199 100644
--- a/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSearchUsersByUserIdItemSegments.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSearchUsersByUserIdItemSegments.g.cs
@@ -14,6 +14,7 @@ public partial class SearchClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -58,6 +59,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponseCon
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.SearchResponse> CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync(
@@ -65,6 +67,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponseCon
             string userId,
 
             global::Recombee.SearchItemSegmentsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -83,22 +86,43 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponseCon
                 securityRequirements: s_CreateByDatabaseIdSearchUsersByUserIdItemSegmentsSecurityRequirements,
                 operationName: "CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/search/users/{userId}/item-segments/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/search/users/{userId}/item-segments/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -108,186 +132,345 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponseCon
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdSearchUsersByUserIdItemSegmentsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdSearchUsersByUserIdItemSegmentsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.SearchResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItemSegments",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/item-segments/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.SearchResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.SearchResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.SearchResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Search Item Segments<br/>
@@ -364,6 +547,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponseCon
         /// }<br/>
         /// ```
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.SearchResponse> CreateByDatabaseIdSearchUsersByUserIdItemSegmentsAsync(
@@ -379,6 +563,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponseCon
             object? expertSettings = default,
             bool? returnAbGroup = default,
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.SearchItemSegmentsParameters
@@ -399,6 +584,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemSegmentsResponseCon
                 databaseId: databaseId,
                 userId: userId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSearchUsersByUserIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSearchUsersByUserIdItems.g.cs
index 3621958..04a7251 100644
--- a/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSearchUsersByUserIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSearchUsersByUserIdItems.g.cs
@@ -14,6 +14,7 @@ public partial class SearchClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -58,6 +59,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponseContent(
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.SearchResponse> CreateByDatabaseIdSearchUsersByUserIdItemsAsync(
@@ -65,6 +67,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponseContent(
             string userId,
 
             global::Recombee.SearchItemsParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -83,22 +86,43 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponseContent(
                 securityRequirements: s_CreateByDatabaseIdSearchUsersByUserIdItemsSecurityRequirements,
                 operationName: "CreateByDatabaseIdSearchUsersByUserIdItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/search/users/{userId}/items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/search/users/{userId}/items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -108,186 +132,345 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdSearchUsersByUserIdItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdSearchUsersByUserIdItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.SearchResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSearchUsersByUserIdItems",
+                                methodName: "CreateByDatabaseIdSearchUsersByUserIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/search/users/{userId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.SearchResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.SearchResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.SearchResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Search Items<br/>
@@ -427,6 +610,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponseContent(
         /// <param name="returnAbGroup">
         /// If there is a custom AB-testing running, return the name of the group to which the request belongs.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.SearchResponse> CreateByDatabaseIdSearchUsersByUserIdItemsAsync(
@@ -444,6 +628,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponseContent(
             global::System.Collections.Generic.Dictionary<string, string>? reqlExpressions = default,
             object? expertSettings = default,
             bool? returnAbGroup = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.SearchItemsParameters
@@ -466,6 +651,7 @@ partial void ProcessCreateByDatabaseIdSearchUsersByUserIdItemsResponseContent(
                 databaseId: databaseId,
                 userId: userId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSynonymsItems.g.cs b/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSynonymsItems.g.cs
index 54d014b..f34ee6c 100644
--- a/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSynonymsItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SearchClient.CreateByDatabaseIdSynonymsItems.g.cs
@@ -14,6 +14,7 @@ public partial class SearchClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -51,12 +52,14 @@ partial void ProcessCreateByDatabaseIdSynonymsItemsResponseContent(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.SearchSynonym> CreateByDatabaseIdSynonymsItemsAsync(
             string databaseId,
 
             global::Recombee.SearchSynonymParams request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -74,22 +77,43 @@ partial void ProcessCreateByDatabaseIdSynonymsItemsResponseContent(
                 securityRequirements: s_CreateByDatabaseIdSynonymsItemsSecurityRequirements,
                 operationName: "CreateByDatabaseIdSynonymsItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/synonyms/items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/synonyms/items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -99,185 +123,344 @@ partial void ProcessCreateByDatabaseIdSynonymsItemsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
-
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdSynonymsItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdSynonymsItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdSynonymsItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSynonymsItems",
+                                methodName: "CreateByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSynonymsItems",
+                                methodName: "CreateByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSynonymsItems",
+                                methodName: "CreateByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_409 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessCreateByDatabaseIdSynonymsItemsResponseContent(
+                    response: __response);
+                ProcessCreateByDatabaseIdSynonymsItemsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.SearchSynonym.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSynonymsItems",
+                                methodName: "CreateByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSynonymsItems",
+                                methodName: "CreateByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.SearchSynonym.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessCreateByDatabaseIdSynonymsItemsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.SearchSynonym.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.SearchSynonym.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Add Search Synonym<br/>
@@ -297,6 +480,7 @@ partial void ProcessCreateByDatabaseIdSynonymsItemsResponseContent(
         /// If set to `true`, only `term` -&gt; `synonym` is considered. If set to `false`, also `synonym` -&gt; `term` works.<br/>
         /// Default: `false`.
         /// </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>
         public async global::System.Threading.Tasks.Task<global::Recombee.SearchSynonym> CreateByDatabaseIdSynonymsItemsAsync(
@@ -304,6 +488,7 @@ partial void ProcessCreateByDatabaseIdSynonymsItemsResponseContent(
             string term,
             string synonym,
             bool? oneWay = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.SearchSynonymParams
@@ -316,6 +501,7 @@ partial void ProcessCreateByDatabaseIdSynonymsItemsResponseContent(
             return await CreateByDatabaseIdSynonymsItemsAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SearchClient.DeleteByDatabaseIdSynonymsItems.g.cs b/src/libs/Recombee/Generated/Recombee.SearchClient.DeleteByDatabaseIdSynonymsItems.g.cs
index 368d072..2c4d6dc 100644
--- a/src/libs/Recombee/Generated/Recombee.SearchClient.DeleteByDatabaseIdSynonymsItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SearchClient.DeleteByDatabaseIdSynonymsItems.g.cs
@@ -14,6 +14,7 @@ public partial class SearchClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -40,10 +41,12 @@ partial void ProcessDeleteByDatabaseIdSynonymsItemsResponse(
         /// Deletes all synonyms defined in the database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdSynonymsItemsAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -58,22 +61,43 @@ partial void ProcessDeleteByDatabaseIdSynonymsItemsResponse(
                 securityRequirements: s_DeleteByDatabaseIdSynonymsItemsSecurityRequirements,
                 operationName: "DeleteByDatabaseIdSynonymsItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/synonyms/items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/synonyms/items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -83,96 +107,255 @@ partial void ProcessDeleteByDatabaseIdSynonymsItemsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdSynonymsItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdSynonymsItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId);
 
-            using var __response = await HttpClient.SendAsync(
+                return __httpRequest;
+            }
+
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
+            {
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
+                {
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItems",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
                 request: __httpRequest,
                 completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
+                    {
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItems",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdSynonymsItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItems",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                    break;
+                }
 
-                try
+                if (__response == null)
                 {
-                    __response.EnsureSuccessStatusCode();
-
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
-                catch (global::System.Exception __ex)
+
+                using (__response)
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
-            }
-            else
-            {
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdSynonymsItemsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItems",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItems",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.SearchClient.DeleteByDatabaseIdSynonymsItemsById.g.cs b/src/libs/Recombee/Generated/Recombee.SearchClient.DeleteByDatabaseIdSynonymsItemsById.g.cs
index c8a7425..314e840 100644
--- a/src/libs/Recombee/Generated/Recombee.SearchClient.DeleteByDatabaseIdSynonymsItemsById.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SearchClient.DeleteByDatabaseIdSynonymsItemsById.g.cs
@@ -14,6 +14,7 @@ public partial class SearchClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,11 +44,13 @@ partial void ProcessDeleteByDatabaseIdSynonymsItemsByIdResponse(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="id"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdSynonymsItemsByIdAsync(
             string databaseId,
             string id,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -63,22 +66,43 @@ partial void ProcessDeleteByDatabaseIdSynonymsItemsByIdResponse(
                 securityRequirements: s_DeleteByDatabaseIdSynonymsItemsByIdSecurityRequirements,
                 operationName: "DeleteByDatabaseIdSynonymsItemsByIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/synonyms/items/{id}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/synonyms/items/{id}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -88,130 +112,289 @@ partial void ProcessDeleteByDatabaseIdSynonymsItemsByIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdSynonymsItemsByIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                id: id);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdSynonymsItemsByIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    id: id);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdSynonymsItemsByIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 404)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItemsById",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsByIdAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/{id}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItemsById",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsByIdAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/{id}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItemsById",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsByIdAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/{id}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
-
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-
-                try
+                    response: __response);
+                ProcessDeleteByDatabaseIdSynonymsItemsByIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItemsById",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsByIdAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/{id}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
+                else
                 {
-                    __response.EnsureSuccessStatusCode();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSynonymsItemsById",
+                                methodName: "DeleteByDatabaseIdSynonymsItemsByIdAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/{id}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.SearchClient.GetByDatabaseIdSynonymsItems.g.cs b/src/libs/Recombee/Generated/Recombee.SearchClient.GetByDatabaseIdSynonymsItems.g.cs
index 0f7a548..1d1e811 100644
--- a/src/libs/Recombee/Generated/Recombee.SearchClient.GetByDatabaseIdSynonymsItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SearchClient.GetByDatabaseIdSynonymsItems.g.cs
@@ -14,6 +14,7 @@ public partial class SearchClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -51,12 +52,14 @@ partial void ProcessGetByDatabaseIdSynonymsItemsResponseContent(
         /// <param name="databaseId"></param>
         /// <param name="count"></param>
         /// <param name="offset"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.ListSearchSynonymsResponse> GetByDatabaseIdSynonymsItemsAsync(
             string databaseId,
             int? count = default,
             int? offset = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -73,26 +76,47 @@ partial void ProcessGetByDatabaseIdSynonymsItemsResponseContent(
                 securityRequirements: s_GetByDatabaseIdSynonymsItemsSecurityRequirements,
                 operationName: "GetByDatabaseIdSynonymsItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/synonyms/items/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddOptionalParameter("count", count?.ToString())
-                .AddOptionalParameter("offset", offset?.ToString()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/synonyms/items/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddOptionalParameter("count", count?.ToString())
+                                .AddOptionalParameter("offset", offset?.ToString()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -102,114 +126,273 @@ partial void ProcessGetByDatabaseIdSynonymsItemsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdSynonymsItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                count: count,
-                offset: offset);
-
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdSynonymsItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    count: count,
+                    offset: offset);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdSynonymsItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
+                return __httpRequest;
+            }
 
-            if (ReadResponseAsString)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
+                {
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSynonymsItems",
+                                methodName: "GetByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
+                    {
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSynonymsItems",
+                                methodName: "GetByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdSynonymsItemsResponseContent(
-                    httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSynonymsItems",
+                                methodName: "GetByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-                    return
-                        global::Recombee.ListSearchSynonymsResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
-            }
-            else
-            {
-                try
+
+                using (__response)
                 {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
 
-                    return
-                        await global::Recombee.ListSearchSynonymsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessGetByDatabaseIdSynonymsItemsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
+                {
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSynonymsItems",
+                                methodName: "GetByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSynonymsItems",
+                                methodName: "GetByDatabaseIdSynonymsItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/synonyms/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdSynonymsItemsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.ListSearchSynonymsResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.ListSearchSynonymsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.SearchClient.g.cs b/src/libs/Recombee/Generated/Recombee.SearchClient.g.cs
index 85030e8..3d2b122 100644
--- a/src/libs/Recombee/Generated/Recombee.SearchClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SearchClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class SearchClient : global::Recombee.ISearchClient, globa
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public SearchClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the SearchClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 SearchClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.Security.g.cs b/src/libs/Recombee/Generated/Recombee.Security.g.cs
index 60ac887..84361bf 100644
--- a/src/libs/Recombee/Generated/Recombee.Security.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.Security.g.cs
@@ -6,6 +6,8 @@ internal sealed class EndPointAuthorizationRequirement
     {
         internal string Type { get; set; } = string.Empty;
 
+        internal string SchemeId { get; set; } = string.Empty;
+
         internal string Location { get; set; } = string.Empty;
 
         internal string Name { get; set; } = string.Empty;
@@ -97,7 +99,18 @@ private static bool Matches(
 
             return requiredAuthorization.Type switch
             {
-                "OAuth2" => true,
+                "OAuth2" => string.Equals(
+                    availableAuthorization.SchemeId,
+                    requiredAuthorization.SchemeId,
+                    global::System.StringComparison.Ordinal),
+                "OpenIdConnect" => string.Equals(
+                    availableAuthorization.SchemeId,
+                    requiredAuthorization.SchemeId,
+                    global::System.StringComparison.Ordinal),
+                "MutualTLS" => string.Equals(
+                    availableAuthorization.SchemeId,
+                    requiredAuthorization.SchemeId,
+                    global::System.StringComparison.Ordinal),
                 "Http" => string.Equals(
                     availableAuthorization.Name,
                     requiredAuthorization.Name,
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
index dd4fc4a..0a47eb8 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -46,6 +47,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdRespo
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
@@ -53,6 +55,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdRespo
             string segmentationId,
 
             global::Recombee.UpdateAutoReQLSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -71,22 +74,43 @@ partial void ProcessCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdRespo
                 securityRequirements: s_CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdSecurityRequirements,
                 operationName: "CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/auto-reql/{segmentationId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/auto-reql/{segmentationId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -96,169 +120,328 @@ partial void ProcessCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdRespo
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -276,6 +459,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdRespo
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
@@ -284,6 +468,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdRespo
             string? expression = default,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.UpdateAutoReQLSegmentationParameters
@@ -297,6 +482,7 @@ await CreateByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
                 databaseId: databaseId,
                 segmentationId: segmentationId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
index 3ee539c..3f57be3 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -46,6 +47,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdRes
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
@@ -53,6 +55,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdRes
             string segmentationId,
 
             global::Recombee.UpdateManualReQLSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -71,22 +74,43 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdRes
                 securityRequirements: s_CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSecurityRequirements,
                 operationName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -96,169 +120,328 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdRes
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -273,6 +456,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdRes
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
@@ -280,6 +464,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdRes
             string segmentationId,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.UpdateManualReQLSegmentationParameters
@@ -292,6 +477,7 @@ await CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
                 databaseId: databaseId,
                 segmentationId: segmentationId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
index e81c5ac..d1f1213 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,6 +50,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSeg
         /// <param name="segmentationId"></param>
         /// <param name="segmentId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
@@ -57,6 +59,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSeg
             string segmentId,
 
             global::Recombee.ManualReQLSegmentParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -76,22 +79,43 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSeg
                 securityRequirements: s_CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdSecurityRequirements,
                 operationName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -101,170 +125,329 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSeg
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId,
-                segmentId: segmentId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId,
+                    segmentId: segmentId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
+                    {
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -280,6 +463,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSeg
         /// <param name="title">
         /// Human-readable name of the Segment that is shown in the Recombee Admin UI.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
@@ -288,6 +472,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSeg
             string segmentId,
             string filter,
             string? title = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.ManualReQLSegmentParameters
@@ -301,6 +486,7 @@ await CreateByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegment
                 segmentationId: segmentationId,
                 segmentId: segmentId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
index 3ad5624..35b7055 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -46,6 +47,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
@@ -53,6 +55,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId
             string segmentationId,
 
             global::Recombee.UpdatePropertyBasedSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -71,22 +74,43 @@ partial void ProcessCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId
                 securityRequirements: s_CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdSecurityRequirements,
                 operationName: "CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/property-based/{segmentationId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/property-based/{segmentationId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -96,169 +120,328 @@ partial void ProcessCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -276,6 +459,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
@@ -284,6 +468,7 @@ partial void ProcessCreateByDatabaseIdSegmentationsPropertyBasedBySegmentationId
             string? propertyName = default,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.UpdatePropertyBasedSegmentationParameters
@@ -297,6 +482,7 @@ await CreateByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
                 databaseId: databaseId,
                 segmentationId: segmentationId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsBySegmentationId.g.cs
index ecdb53a..a4238c5 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsBySegmentationId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,11 +44,13 @@ partial void ProcessDeleteByDatabaseIdSegmentationsBySegmentationIdResponse(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdSegmentationsBySegmentationIdAsync(
             string databaseId,
             string segmentationId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -63,22 +66,43 @@ partial void ProcessDeleteByDatabaseIdSegmentationsBySegmentationIdResponse(
                 securityRequirements: s_DeleteByDatabaseIdSegmentationsBySegmentationIdSecurityRequirements,
                 operationName: "DeleteByDatabaseIdSegmentationsBySegmentationIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/{segmentationId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/{segmentationId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -88,130 +112,289 @@ partial void ProcessDeleteByDatabaseIdSegmentationsBySegmentationIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdSegmentationsBySegmentationIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdSegmentationsBySegmentationIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdSegmentationsBySegmentationIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 404)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsBySegmentationId",
+                                methodName: "DeleteByDatabaseIdSegmentationsBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/{segmentationId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsBySegmentationId",
+                                methodName: "DeleteByDatabaseIdSegmentationsBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/{segmentationId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsBySegmentationId",
+                                methodName: "DeleteByDatabaseIdSegmentationsBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/{segmentationId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
-
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-
-                try
+                    response: __response);
+                ProcessDeleteByDatabaseIdSegmentationsBySegmentationIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsBySegmentationId",
+                                methodName: "DeleteByDatabaseIdSegmentationsBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/{segmentationId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
+                else
                 {
-                    __response.EnsureSuccessStatusCode();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsBySegmentationId",
+                                methodName: "DeleteByDatabaseIdSegmentationsBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/{segmentationId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
index 06e1bec..53e9eef 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -46,12 +47,14 @@ partial void ProcessDeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSeg
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></param>
         /// <param name="segmentId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
             string databaseId,
             string segmentationId,
             string segmentId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessDeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSeg
                 securityRequirements: s_DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdSecurityRequirements,
                 operationName: "DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,163 +117,322 @@ partial void ProcessDeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSeg
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId,
-                segmentId: segmentId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId,
+                    segmentId: segmentId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "DeleteByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.GetByDatabaseIdSegmentationsList.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.GetByDatabaseIdSegmentationsList.g.cs
index a0d09b6..7c79a9d 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.GetByDatabaseIdSegmentationsList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.GetByDatabaseIdSegmentationsList.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdSegmentationsListResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="sourceType"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.ListSegmentationsResponse> GetByDatabaseIdSegmentationsListAsync(
             string databaseId,
             string sourceType,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,25 +71,46 @@ partial void ProcessGetByDatabaseIdSegmentationsListResponseContent(
                 securityRequirements: s_GetByDatabaseIdSegmentationsListSecurityRequirements,
                 operationName: "GetByDatabaseIdSegmentationsListAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/list/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddRequiredParameter("sourceType", sourceType) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/list/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddRequiredParameter("sourceType", sourceType) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -96,113 +120,272 @@ partial void ProcessGetByDatabaseIdSegmentationsListResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdSegmentationsListRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                sourceType: sourceType);
-
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdSegmentationsListRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    sourceType: sourceType);
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdSegmentationsListResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
+                return __httpRequest;
+            }
 
-            if (ReadResponseAsString)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
+                {
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsList",
+                                methodName: "GetByDatabaseIdSegmentationsListAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
+                    {
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsList",
+                                methodName: "GetByDatabaseIdSegmentationsListAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdSegmentationsListResponseContent(
-                    httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsList",
+                                methodName: "GetByDatabaseIdSegmentationsListAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
 
-                    return
-                        global::Recombee.ListSegmentationsResponse.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
-            }
-            else
-            {
-                try
+
+                using (__response)
                 {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
 
-                    return
-                        await global::Recombee.ListSegmentationsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessGetByDatabaseIdSegmentationsListResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
+                {
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsList",
+                                methodName: "GetByDatabaseIdSegmentationsListAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsList",
+                                methodName: "GetByDatabaseIdSegmentationsListAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdSegmentationsListResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.ListSegmentationsResponse.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.ListSegmentationsResponse.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.GetByDatabaseIdSegmentationsListBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.GetByDatabaseIdSegmentationsListBySegmentationId.g.cs
index 88959ca..f1682aa 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.GetByDatabaseIdSegmentationsListBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.GetByDatabaseIdSegmentationsListBySegmentationId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdSegmentationsListBySegmentationIdResponseCont
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.Segmentation> GetByDatabaseIdSegmentationsListBySegmentationIdAsync(
             string databaseId,
             string segmentationId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdSegmentationsListBySegmentationIdResponseCont
                 securityRequirements: s_GetByDatabaseIdSegmentationsListBySegmentationIdSecurityRequirements,
                 operationName: "GetByDatabaseIdSegmentationsListBySegmentationIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/list/{segmentationId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/list/{segmentationId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,146 +117,305 @@ partial void ProcessGetByDatabaseIdSegmentationsListBySegmentationIdResponseCont
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdSegmentationsListBySegmentationIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdSegmentationsListBySegmentationIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdSegmentationsListBySegmentationIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 404)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsListBySegmentationId",
+                                methodName: "GetByDatabaseIdSegmentationsListBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/{segmentationId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsListBySegmentationId",
+                                methodName: "GetByDatabaseIdSegmentationsListBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/{segmentationId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsListBySegmentationId",
+                                methodName: "GetByDatabaseIdSegmentationsListBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/{segmentationId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdSegmentationsListBySegmentationIdResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdSegmentationsListBySegmentationIdResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.Segmentation.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsListBySegmentationId",
+                                methodName: "GetByDatabaseIdSegmentationsListBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/{segmentationId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSegmentationsListBySegmentationId",
+                                methodName: "GetByDatabaseIdSegmentationsListBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/list/{segmentationId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.Segmentation.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdSegmentationsListBySegmentationIdResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.Segmentation.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.Segmentation.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
index 1787cfc..3343214 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsAutoReqlBySegmentationId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -47,6 +48,7 @@ partial void ProcessPutByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
@@ -54,6 +56,7 @@ partial void ProcessPutByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse
             string segmentationId,
 
             global::Recombee.CreateAutoReQLSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -72,22 +75,43 @@ partial void ProcessPutByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse
                 securityRequirements: s_PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdSecurityRequirements,
                 operationName: "PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/auto-reql/{segmentationId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/auto-reql/{segmentationId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -97,137 +121,296 @@ partial void ProcessPutByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdSegmentationsAutoReqlBySegmentationIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdSegmentationsAutoReqlBySegmentationIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
-
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-
-                }
-                catch (global::System.Exception __ex)
+                    response: __response);
+                ProcessPutByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
+                else
                 {
-                    __response.EnsureSuccessStatusCode();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsAutoReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/auto-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Create Auto ReQL Segmentation<br/>
@@ -248,6 +431,7 @@ partial void ProcessPutByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
@@ -257,6 +441,7 @@ partial void ProcessPutByDatabaseIdSegmentationsAutoReqlBySegmentationIdResponse
             string expression,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.CreateAutoReQLSegmentationParameters
@@ -271,6 +456,7 @@ await PutByDatabaseIdSegmentationsAutoReqlBySegmentationIdAsync(
                 databaseId: databaseId,
                 segmentationId: segmentationId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
index f73c06f..1cc9cbb 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -47,6 +48,7 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdRespon
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
@@ -54,6 +56,7 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdRespon
             string segmentationId,
 
             global::Recombee.CreateManualReQLSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -72,22 +75,43 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdRespon
                 securityRequirements: s_PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSecurityRequirements,
                 operationName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -97,137 +121,296 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdRespon
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdSegmentationsManualReqlBySegmentationIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdSegmentationsManualReqlBySegmentationIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
-
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-
-                }
-                catch (global::System.Exception __ex)
+                    response: __response);
+                ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
+                else
                 {
-                    __response.EnsureSuccessStatusCode();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
         /// <summary>
         /// Create Manual ReQL Segmentation<br/>
@@ -245,6 +428,7 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdRespon
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
@@ -253,6 +437,7 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdRespon
             string sourceType,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.CreateManualReQLSegmentationParameters
@@ -266,6 +451,7 @@ await PutByDatabaseIdSegmentationsManualReqlBySegmentationIdAsync(
                 databaseId: databaseId,
                 segmentationId: segmentationId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
index fbdb48b..7772d1f 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -50,6 +51,7 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmen
         /// <param name="segmentationId"></param>
         /// <param name="segmentId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
@@ -58,6 +60,7 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmen
             string segmentId,
 
             global::Recombee.ManualReQLSegmentParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -77,22 +80,43 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmen
                 securityRequirements: s_PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdSecurityRequirements,
                 operationName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -102,170 +126,329 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmen
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId,
-                segmentId: segmentId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId,
+                    segmentId: segmentId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
+                    {
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentId",
+                                methodName: "PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/manual-reql/{segmentationId}/segments/{segmentId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -282,6 +465,7 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmen
         /// <param name="title">
         /// Human-readable name of the Segment that is shown in the Recombee Admin UI.
         /// </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>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdAsync(
@@ -290,6 +474,7 @@ partial void ProcessPutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmen
             string segmentId,
             string filter,
             string? title = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.ManualReQLSegmentParameters
@@ -303,6 +488,7 @@ await PutByDatabaseIdSegmentationsManualReqlBySegmentationIdSegmentsBySegmentIdA
                 segmentationId: segmentationId,
                 segmentId: segmentId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
index a05b6ec..57be722 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.PutByDatabaseIdSegmentationsPropertyBasedBySegmentationId.g.cs
@@ -14,6 +14,7 @@ public partial class SegmentationsDefinitionClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,6 +49,7 @@ partial void ProcessPutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRes
         /// <param name="databaseId"></param>
         /// <param name="segmentationId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
@@ -55,6 +57,7 @@ partial void ProcessPutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRes
             string segmentationId,
 
             global::Recombee.CreatePropertyBasedSegmentationParameters request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -73,22 +76,43 @@ partial void ProcessPutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRes
                 securityRequirements: s_PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdSecurityRequirements,
                 operationName: "PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/segmentations/property-based/{segmentationId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/segmentations/property-based/{segmentationId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -98,169 +122,328 @@ partial void ProcessPutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRes
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                segmentationId: segmentationId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    segmentationId: segmentationId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessPutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSegmentationsPropertyBasedBySegmentationId",
+                                methodName: "PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync",
+                                pathTemplate: "$\"/{databaseId}/segmentations/property-based/{segmentationId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -283,6 +466,7 @@ partial void ProcessPutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRes
         /// <param name="description">
         /// Description that is shown in the Recombee Admin UI.
         /// </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>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
@@ -292,6 +476,7 @@ partial void ProcessPutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdRes
             string propertyName,
             string? title = default,
             string? description = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.CreatePropertyBasedSegmentationParameters
@@ -306,6 +491,7 @@ await PutByDatabaseIdSegmentationsPropertyBasedBySegmentationIdAsync(
                 databaseId: databaseId,
                 segmentationId: segmentationId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.g.cs b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.g.cs
index a71ec94..2732eee 100644
--- a/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SegmentationsDefinitionClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class SegmentationsDefinitionClient : global::Recombee.ISe
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public SegmentationsDefinitionClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the SegmentationsDefinitionClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 SegmentationsDefinitionClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.SeriesClient.CreateByDatabaseIdSeriesBySeriesIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.SeriesClient.CreateByDatabaseIdSeriesBySeriesIdItems.g.cs
index 8185eea..f2a48d3 100644
--- a/src/libs/Recombee/Generated/Recombee.SeriesClient.CreateByDatabaseIdSeriesBySeriesIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SeriesClient.CreateByDatabaseIdSeriesBySeriesIdItems.g.cs
@@ -14,6 +14,7 @@ public partial class SeriesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -46,6 +47,7 @@ partial void ProcessCreateByDatabaseIdSeriesBySeriesIdItemsResponse(
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSeriesBySeriesIdItemsAsync(
@@ -53,6 +55,7 @@ partial void ProcessCreateByDatabaseIdSeriesBySeriesIdItemsResponse(
             string seriesId,
 
             global::Recombee.SeriesItem request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -71,22 +74,43 @@ partial void ProcessCreateByDatabaseIdSeriesBySeriesIdItemsResponse(
                 securityRequirements: s_CreateByDatabaseIdSeriesBySeriesIdItemsSecurityRequirements,
                 operationName: "CreateByDatabaseIdSeriesBySeriesIdItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/series/{seriesId}/items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/series/{seriesId}/items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -96,202 +120,361 @@ partial void ProcessCreateByDatabaseIdSeriesBySeriesIdItemsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdSeriesBySeriesIdItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                seriesId: seriesId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdSeriesBySeriesIdItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    seriesId: seriesId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdSeriesBySeriesIdItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "CreateByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "CreateByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "CreateByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdSeriesBySeriesIdItemsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "CreateByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "CreateByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -312,6 +495,7 @@ partial void ProcessCreateByDatabaseIdSeriesBySeriesIdItemsResponse(
         /// <param name="cascadeCreate">
         /// Indicates that any non-existing entity specified within the request should be created (as if corresponding PUT requests were invoked). This concerns both the `seriesId` and the `itemId`. If `cascadeCreate` is set to true, the behavior also depends on the `itemType`. In case of `item`, an item is created, in case of `series` a series + corresponding item with the same ID is created.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdSeriesBySeriesIdItemsAsync(
@@ -321,6 +505,7 @@ partial void ProcessCreateByDatabaseIdSeriesBySeriesIdItemsResponse(
             string itemId,
             double time,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.SeriesItem
@@ -335,6 +520,7 @@ await CreateByDatabaseIdSeriesBySeriesIdItemsAsync(
                 databaseId: databaseId,
                 seriesId: seriesId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SeriesClient.DeleteByDatabaseIdSeriesBySeriesId.g.cs b/src/libs/Recombee/Generated/Recombee.SeriesClient.DeleteByDatabaseIdSeriesBySeriesId.g.cs
index 41d5a4e..bf66255 100644
--- a/src/libs/Recombee/Generated/Recombee.SeriesClient.DeleteByDatabaseIdSeriesBySeriesId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SeriesClient.DeleteByDatabaseIdSeriesBySeriesId.g.cs
@@ -14,6 +14,7 @@ public partial class SeriesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -47,6 +48,7 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdResponse(
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdSeriesBySeriesIdAsync(
@@ -54,6 +56,7 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdResponse(
             string seriesId,
 
             global::Recombee.DeleteSeries request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -72,22 +75,43 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdResponse(
                 securityRequirements: s_DeleteByDatabaseIdSeriesBySeriesIdSecurityRequirements,
                 operationName: "DeleteByDatabaseIdSeriesBySeriesIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/series/{seriesId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/series/{seriesId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -97,169 +121,328 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdSeriesBySeriesIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                seriesId: seriesId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdSeriesBySeriesIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    seriesId: seriesId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdSeriesBySeriesIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesId",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesId",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesId",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdSeriesBySeriesIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesId",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesId",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -272,12 +455,14 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdResponse(
         /// <param name="cascadeDelete">
         /// If set to `true`, item with the same ID as seriesId will be also deleted. Default is `false`.
         /// </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>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdSeriesBySeriesIdAsync(
             string databaseId,
             string seriesId,
             bool? cascadeDelete = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.DeleteSeries
@@ -289,6 +474,7 @@ await DeleteByDatabaseIdSeriesBySeriesIdAsync(
                 databaseId: databaseId,
                 seriesId: seriesId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SeriesClient.DeleteByDatabaseIdSeriesBySeriesIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.SeriesClient.DeleteByDatabaseIdSeriesBySeriesIdItems.g.cs
index f03c71f..ff7d27c 100644
--- a/src/libs/Recombee/Generated/Recombee.SeriesClient.DeleteByDatabaseIdSeriesBySeriesIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SeriesClient.DeleteByDatabaseIdSeriesBySeriesIdItems.g.cs
@@ -14,6 +14,7 @@ public partial class SeriesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -46,6 +47,7 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdItemsResponse(
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdSeriesBySeriesIdItemsAsync(
@@ -53,6 +55,7 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdItemsResponse(
             string seriesId,
 
             global::Recombee.RemoveSeriesItem request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -71,22 +74,43 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdItemsResponse(
                 securityRequirements: s_DeleteByDatabaseIdSeriesBySeriesIdItemsSecurityRequirements,
                 operationName: "DeleteByDatabaseIdSeriesBySeriesIdItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/series/{seriesId}/items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/series/{seriesId}/items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -96,169 +120,328 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdItemsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdSeriesBySeriesIdItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                seriesId: seriesId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdSeriesBySeriesIdItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    seriesId: seriesId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdSeriesBySeriesIdItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdSeriesBySeriesIdItemsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "DeleteByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -273,6 +456,7 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdItemsResponse(
         /// <param name="itemId">
         /// ID of the item iff `itemType` is `item`. ID of the series iff `itemType` is `series`.
         /// </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>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdSeriesBySeriesIdItemsAsync(
@@ -280,6 +464,7 @@ partial void ProcessDeleteByDatabaseIdSeriesBySeriesIdItemsResponse(
             string seriesId,
             string itemType,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.RemoveSeriesItem
@@ -292,6 +477,7 @@ await DeleteByDatabaseIdSeriesBySeriesIdItemsAsync(
                 databaseId: databaseId,
                 seriesId: seriesId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SeriesClient.GetByDatabaseIdSeriesBySeriesIdItems.g.cs b/src/libs/Recombee/Generated/Recombee.SeriesClient.GetByDatabaseIdSeriesBySeriesIdItems.g.cs
index 258ea6c..37d50e1 100644
--- a/src/libs/Recombee/Generated/Recombee.SeriesClient.GetByDatabaseIdSeriesBySeriesIdItems.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SeriesClient.GetByDatabaseIdSeriesBySeriesIdItems.g.cs
@@ -14,6 +14,7 @@ public partial class SeriesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdSeriesBySeriesIdItemsResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.SeriesItem>> GetByDatabaseIdSeriesBySeriesIdItemsAsync(
             string databaseId,
             string seriesId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdSeriesBySeriesIdItemsResponseContent(
                 securityRequirements: s_GetByDatabaseIdSeriesBySeriesIdItemsSecurityRequirements,
                 operationName: "GetByDatabaseIdSeriesBySeriesIdItemsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/series/{seriesId}/items/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/series/{seriesId}/items/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdSeriesBySeriesIdItemsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdSeriesBySeriesIdItemsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                seriesId: seriesId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdSeriesBySeriesIdItemsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    seriesId: seriesId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdSeriesBySeriesIdItemsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "GetByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "GetByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "GetByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdSeriesBySeriesIdItemsResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdSeriesBySeriesIdItemsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.SeriesItem>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.SeriesItem>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "GetByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesBySeriesIdItems",
+                                methodName: "GetByDatabaseIdSeriesBySeriesIdItemsAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}/items/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.SeriesItem>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.SeriesItem>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdSeriesBySeriesIdItemsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.SeriesItem>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.SeriesItem>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.SeriesItem>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.SeriesItem>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.SeriesClient.GetByDatabaseIdSeriesList.g.cs b/src/libs/Recombee/Generated/Recombee.SeriesClient.GetByDatabaseIdSeriesList.g.cs
index 7a1affd..6cadf39 100644
--- a/src/libs/Recombee/Generated/Recombee.SeriesClient.GetByDatabaseIdSeriesList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SeriesClient.GetByDatabaseIdSeriesList.g.cs
@@ -14,6 +14,7 @@ public partial class SeriesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -45,10 +46,12 @@ partial void ProcessGetByDatabaseIdSeriesListResponseContent(
         /// Gets the list of all the series currently present in the database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Series>> GetByDatabaseIdSeriesListAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -63,22 +66,43 @@ partial void ProcessGetByDatabaseIdSeriesListResponseContent(
                 securityRequirements: s_GetByDatabaseIdSeriesListSecurityRequirements,
                 operationName: "GetByDatabaseIdSeriesListAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/series/list/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/series/list/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -88,145 +112,304 @@ partial void ProcessGetByDatabaseIdSeriesListResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdSeriesListRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdSeriesListRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdSeriesListResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 404)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesList",
+                                methodName: "GetByDatabaseIdSeriesListAsync",
+                                pathTemplate: "$\"/{databaseId}/series/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesList",
+                                methodName: "GetByDatabaseIdSeriesListAsync",
+                                pathTemplate: "$\"/{databaseId}/series/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesList",
+                                methodName: "GetByDatabaseIdSeriesListAsync",
+                                pathTemplate: "$\"/{databaseId}/series/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdSeriesListResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdSeriesListResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Series>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Series>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesList",
+                                methodName: "GetByDatabaseIdSeriesListAsync",
+                                pathTemplate: "$\"/{databaseId}/series/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdSeriesList",
+                                methodName: "GetByDatabaseIdSeriesListAsync",
+                                pathTemplate: "$\"/{databaseId}/series/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Series>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Series>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdSeriesListResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Series>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Series>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Series>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Series>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.SeriesClient.PutByDatabaseIdSeriesBySeriesId.g.cs b/src/libs/Recombee/Generated/Recombee.SeriesClient.PutByDatabaseIdSeriesBySeriesId.g.cs
index 9e601e5..028f9db 100644
--- a/src/libs/Recombee/Generated/Recombee.SeriesClient.PutByDatabaseIdSeriesBySeriesId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SeriesClient.PutByDatabaseIdSeriesBySeriesId.g.cs
@@ -14,6 +14,7 @@ public partial class SeriesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -46,6 +47,7 @@ partial void ProcessPutByDatabaseIdSeriesBySeriesIdResponse(
         /// <param name="databaseId"></param>
         /// <param name="seriesId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSeriesBySeriesIdAsync(
@@ -53,6 +55,7 @@ partial void ProcessPutByDatabaseIdSeriesBySeriesIdResponse(
             string seriesId,
 
             global::Recombee.AddSeries request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -71,22 +74,43 @@ partial void ProcessPutByDatabaseIdSeriesBySeriesIdResponse(
                 securityRequirements: s_PutByDatabaseIdSeriesBySeriesIdSecurityRequirements,
                 operationName: "PutByDatabaseIdSeriesBySeriesIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/series/{seriesId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/series/{seriesId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -96,169 +120,328 @@ partial void ProcessPutByDatabaseIdSeriesBySeriesIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdSeriesBySeriesIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                seriesId: seriesId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdSeriesBySeriesIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    seriesId: seriesId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdSeriesBySeriesIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSeriesBySeriesId",
+                                methodName: "PutByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSeriesBySeriesId",
+                                methodName: "PutByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSeriesBySeriesId",
+                                methodName: "PutByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessPutByDatabaseIdSeriesBySeriesIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSeriesBySeriesId",
+                                methodName: "PutByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdSeriesBySeriesId",
+                                methodName: "PutByDatabaseIdSeriesBySeriesIdAsync",
+                                pathTemplate: "$\"/{databaseId}/series/{seriesId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -270,12 +453,14 @@ partial void ProcessPutByDatabaseIdSeriesBySeriesIdResponse(
         /// <param name="cascadeCreate">
         /// If set to `true`, the item will be created with the same ID as the series. Default is `true`.
         /// </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>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdSeriesBySeriesIdAsync(
             string databaseId,
             string seriesId,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.AddSeries
@@ -287,6 +472,7 @@ await PutByDatabaseIdSeriesBySeriesIdAsync(
                 databaseId: databaseId,
                 seriesId: seriesId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.SeriesClient.g.cs b/src/libs/Recombee/Generated/Recombee.SeriesClient.g.cs
index 6d1cc27..84645b9 100644
--- a/src/libs/Recombee/Generated/Recombee.SeriesClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.SeriesClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class SeriesClient : global::Recombee.ISeriesClient, globa
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public SeriesClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the SeriesClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 SeriesClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdBookmarks.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdBookmarks.g.cs
index 008c8fe..bbcba6a 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdBookmarks.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdBookmarks.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,12 +44,14 @@ partial void ProcessCreateByDatabaseIdBookmarksResponse(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdBookmarksAsync(
             string databaseId,
 
             global::Recombee.Bookmark request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -66,22 +69,43 @@ partial void ProcessCreateByDatabaseIdBookmarksResponse(
                 securityRequirements: s_CreateByDatabaseIdBookmarksSecurityRequirements,
                 operationName: "CreateByDatabaseIdBookmarksAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/bookmarks/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/bookmarks/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -91,201 +115,360 @@ partial void ProcessCreateByDatabaseIdBookmarksResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdBookmarksRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdBookmarksRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdBookmarksResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBookmarks",
+                                methodName: "CreateByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBookmarks",
+                                methodName: "CreateByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBookmarks",
+                                methodName: "CreateByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdBookmarksResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBookmarks",
+                                methodName: "CreateByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdBookmarks",
+                                methodName: "CreateByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -311,6 +494,7 @@ partial void ProcessCreateByDatabaseIdBookmarksResponse(
         /// <param name="additionalData">
         /// A dictionary of additional data for the interaction.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdBookmarksAsync(
@@ -321,6 +505,7 @@ partial void ProcessCreateByDatabaseIdBookmarksResponse(
             bool? cascadeCreate = default,
             string? recommId = default,
             object? additionalData = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.Bookmark
@@ -336,6 +521,7 @@ partial void ProcessCreateByDatabaseIdBookmarksResponse(
             await CreateByDatabaseIdBookmarksAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdCartadditions.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdCartadditions.g.cs
index 647fbc2..af68de4 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdCartadditions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdCartadditions.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,12 +44,14 @@ partial void ProcessCreateByDatabaseIdCartadditionsResponse(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdCartadditionsAsync(
             string databaseId,
 
             global::Recombee.CartAddition request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -66,22 +69,43 @@ partial void ProcessCreateByDatabaseIdCartadditionsResponse(
                 securityRequirements: s_CreateByDatabaseIdCartadditionsSecurityRequirements,
                 operationName: "CreateByDatabaseIdCartadditionsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/cartadditions/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/cartadditions/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -91,201 +115,360 @@ partial void ProcessCreateByDatabaseIdCartadditionsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdCartadditionsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdCartadditionsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdCartadditionsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdCartadditions",
+                                methodName: "CreateByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdCartadditions",
+                                methodName: "CreateByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdCartadditions",
+                                methodName: "CreateByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdCartadditionsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdCartadditions",
+                                methodName: "CreateByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdCartadditions",
+                                methodName: "CreateByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -317,6 +500,7 @@ partial void ProcessCreateByDatabaseIdCartadditionsResponse(
         /// <param name="additionalData">
         /// A dictionary of additional data for the interaction.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdCartadditionsAsync(
@@ -329,6 +513,7 @@ partial void ProcessCreateByDatabaseIdCartadditionsResponse(
             double? price = default,
             string? recommId = default,
             object? additionalData = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.CartAddition
@@ -346,6 +531,7 @@ partial void ProcessCreateByDatabaseIdCartadditionsResponse(
             await CreateByDatabaseIdCartadditionsAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdDetailviews.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdDetailviews.g.cs
index 3948f11..4ecc03e 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdDetailviews.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdDetailviews.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,12 +44,14 @@ partial void ProcessCreateByDatabaseIdDetailviewsResponse(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdDetailviewsAsync(
             string databaseId,
 
             global::Recombee.DetailView request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -66,22 +69,43 @@ partial void ProcessCreateByDatabaseIdDetailviewsResponse(
                 securityRequirements: s_CreateByDatabaseIdDetailviewsSecurityRequirements,
                 operationName: "CreateByDatabaseIdDetailviewsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/detailviews/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/detailviews/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -91,201 +115,360 @@ partial void ProcessCreateByDatabaseIdDetailviewsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdDetailviewsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdDetailviewsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdDetailviewsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdDetailviews",
+                                methodName: "CreateByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdDetailviews",
+                                methodName: "CreateByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdDetailviews",
+                                methodName: "CreateByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdDetailviewsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdDetailviews",
+                                methodName: "CreateByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdDetailviews",
+                                methodName: "CreateByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -317,6 +500,7 @@ partial void ProcessCreateByDatabaseIdDetailviewsResponse(
         /// <param name="autoPresented">
         /// Indicates whether the item was automatically presented to the user (e.g., in a swiping feed) or explicitly requested by the user (e.g., by clicking on a link). Defaults to `false`.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdDetailviewsAsync(
@@ -329,6 +513,7 @@ partial void ProcessCreateByDatabaseIdDetailviewsResponse(
             string? recommId = default,
             object? additionalData = default,
             bool? autoPresented = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.DetailView
@@ -346,6 +531,7 @@ partial void ProcessCreateByDatabaseIdDetailviewsResponse(
             await CreateByDatabaseIdDetailviewsAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdPurchases.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdPurchases.g.cs
index 08a61b6..e77e67f 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdPurchases.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdPurchases.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,12 +44,14 @@ partial void ProcessCreateByDatabaseIdPurchasesResponse(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdPurchasesAsync(
             string databaseId,
 
             global::Recombee.Purchase request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -66,22 +69,43 @@ partial void ProcessCreateByDatabaseIdPurchasesResponse(
                 securityRequirements: s_CreateByDatabaseIdPurchasesSecurityRequirements,
                 operationName: "CreateByDatabaseIdPurchasesAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/purchases/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/purchases/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -91,201 +115,360 @@ partial void ProcessCreateByDatabaseIdPurchasesResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdPurchasesRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdPurchasesRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdPurchasesResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdPurchases",
+                                methodName: "CreateByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdPurchases",
+                                methodName: "CreateByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdPurchases",
+                                methodName: "CreateByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdPurchasesResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdPurchases",
+                                methodName: "CreateByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdPurchases",
+                                methodName: "CreateByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -320,6 +503,7 @@ partial void ProcessCreateByDatabaseIdPurchasesResponse(
         /// <param name="additionalData">
         /// A dictionary of additional data for the interaction.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdPurchasesAsync(
@@ -333,6 +517,7 @@ partial void ProcessCreateByDatabaseIdPurchasesResponse(
             double? profit = default,
             string? recommId = default,
             object? additionalData = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.Purchase
@@ -351,6 +536,7 @@ partial void ProcessCreateByDatabaseIdPurchasesResponse(
             await CreateByDatabaseIdPurchasesAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdRatings.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdRatings.g.cs
index 398f75d..0e1a26e 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdRatings.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdRatings.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,12 +44,14 @@ partial void ProcessCreateByDatabaseIdRatingsResponse(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdRatingsAsync(
             string databaseId,
 
             global::Recombee.Rating request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -66,22 +69,43 @@ partial void ProcessCreateByDatabaseIdRatingsResponse(
                 securityRequirements: s_CreateByDatabaseIdRatingsSecurityRequirements,
                 operationName: "CreateByDatabaseIdRatingsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/ratings/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/ratings/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -91,201 +115,360 @@ partial void ProcessCreateByDatabaseIdRatingsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdRatingsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdRatingsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdRatingsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRatings",
+                                methodName: "CreateByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRatings",
+                                methodName: "CreateByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRatings",
+                                methodName: "CreateByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdRatingsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRatings",
+                                methodName: "CreateByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdRatings",
+                                methodName: "CreateByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -314,6 +497,7 @@ partial void ProcessCreateByDatabaseIdRatingsResponse(
         /// <param name="additionalData">
         /// A dictionary of additional data for the interaction.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdRatingsAsync(
@@ -325,6 +509,7 @@ partial void ProcessCreateByDatabaseIdRatingsResponse(
             bool? cascadeCreate = default,
             string? recommId = default,
             object? additionalData = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.Rating
@@ -341,6 +526,7 @@ partial void ProcessCreateByDatabaseIdRatingsResponse(
             await CreateByDatabaseIdRatingsAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdViewportions.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdViewportions.g.cs
index 0b04808..f3cec51 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdViewportions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.CreateByDatabaseIdViewportions.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -44,12 +45,14 @@ partial void ProcessCreateByDatabaseIdViewportionsResponse(
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdViewportionsAsync(
             string databaseId,
 
             global::Recombee.ViewPortion request,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -67,22 +70,43 @@ partial void ProcessCreateByDatabaseIdViewportionsResponse(
                 securityRequirements: s_CreateByDatabaseIdViewportionsSecurityRequirements,
                 operationName: "CreateByDatabaseIdViewportionsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/viewportions/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/viewportions/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -92,201 +116,360 @@ partial void ProcessCreateByDatabaseIdViewportionsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = request.ToJson(JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdViewportionsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdViewportionsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdViewportionsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdViewportions",
+                                methodName: "CreateByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdViewportions",
+                                methodName: "CreateByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdViewportions",
+                                methodName: "CreateByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdViewportionsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdViewportions",
+                                methodName: "CreateByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdViewportions",
+                                methodName: "CreateByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
         /// <summary>
@@ -325,6 +508,7 @@ partial void ProcessCreateByDatabaseIdViewportionsResponse(
         /// <param name="timeSpent">
         /// The duration (in seconds) that the user viewed the item. In update requests, this value may only increase and is required only if it has changed.
         /// </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>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdViewportionsAsync(
@@ -339,6 +523,7 @@ partial void ProcessCreateByDatabaseIdViewportionsResponse(
             object? additionalData = default,
             bool? autoPresented = default,
             double? timeSpent = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             var __request = new global::Recombee.ViewPortion
@@ -358,6 +543,7 @@ partial void ProcessCreateByDatabaseIdViewportionsResponse(
             await CreateByDatabaseIdViewportionsAsync(
                 databaseId: databaseId,
                 request: __request,
+                requestOptions: requestOptions,
                 cancellationToken: cancellationToken).ConfigureAwait(false);
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdBookmarks.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdBookmarks.g.cs
index 1e06166..8e3ad51 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdBookmarks.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdBookmarks.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,6 +50,7 @@ partial void ProcessDeleteByDatabaseIdBookmarksResponse(
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdBookmarksAsync(
@@ -56,6 +58,7 @@ partial void ProcessDeleteByDatabaseIdBookmarksResponse(
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -73,27 +76,48 @@ partial void ProcessDeleteByDatabaseIdBookmarksResponse(
                 securityRequirements: s_DeleteByDatabaseIdBookmarksSecurityRequirements,
                 operationName: "DeleteByDatabaseIdBookmarksAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/bookmarks/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddRequiredParameter("userId", userId)
-                .AddRequiredParameter("itemId", itemId)
-                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/bookmarks/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddRequiredParameter("userId", userId)
+                                .AddRequiredParameter("itemId", itemId)
+                                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,164 +127,323 @@ partial void ProcessDeleteByDatabaseIdBookmarksResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdBookmarksRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                itemId: itemId,
-                timestamp: timestamp);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdBookmarksRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    itemId: itemId,
+                    timestamp: timestamp);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdBookmarksResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdBookmarks",
+                                methodName: "DeleteByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdBookmarks",
+                                methodName: "DeleteByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdBookmarks",
+                                methodName: "DeleteByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdBookmarksResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdBookmarks",
+                                methodName: "DeleteByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdBookmarks",
+                                methodName: "DeleteByDatabaseIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/bookmarks/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdCartadditions.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdCartadditions.g.cs
index 746e8d7..79e923c 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdCartadditions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdCartadditions.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,6 +50,7 @@ partial void ProcessDeleteByDatabaseIdCartadditionsResponse(
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdCartadditionsAsync(
@@ -56,6 +58,7 @@ partial void ProcessDeleteByDatabaseIdCartadditionsResponse(
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -73,27 +76,48 @@ partial void ProcessDeleteByDatabaseIdCartadditionsResponse(
                 securityRequirements: s_DeleteByDatabaseIdCartadditionsSecurityRequirements,
                 operationName: "DeleteByDatabaseIdCartadditionsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/cartadditions/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddRequiredParameter("userId", userId)
-                .AddRequiredParameter("itemId", itemId)
-                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/cartadditions/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddRequiredParameter("userId", userId)
+                                .AddRequiredParameter("itemId", itemId)
+                                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,164 +127,323 @@ partial void ProcessDeleteByDatabaseIdCartadditionsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdCartadditionsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                itemId: itemId,
-                timestamp: timestamp);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdCartadditionsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    itemId: itemId,
+                    timestamp: timestamp);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdCartadditionsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdCartadditions",
+                                methodName: "DeleteByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdCartadditions",
+                                methodName: "DeleteByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdCartadditions",
+                                methodName: "DeleteByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdCartadditionsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdCartadditions",
+                                methodName: "DeleteByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdCartadditions",
+                                methodName: "DeleteByDatabaseIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/cartadditions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdDetailviews.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdDetailviews.g.cs
index b2a038b..8db2391 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdDetailviews.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdDetailviews.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,6 +50,7 @@ partial void ProcessDeleteByDatabaseIdDetailviewsResponse(
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdDetailviewsAsync(
@@ -56,6 +58,7 @@ partial void ProcessDeleteByDatabaseIdDetailviewsResponse(
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -73,27 +76,48 @@ partial void ProcessDeleteByDatabaseIdDetailviewsResponse(
                 securityRequirements: s_DeleteByDatabaseIdDetailviewsSecurityRequirements,
                 operationName: "DeleteByDatabaseIdDetailviewsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/detailviews/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddRequiredParameter("userId", userId)
-                .AddRequiredParameter("itemId", itemId)
-                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/detailviews/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddRequiredParameter("userId", userId)
+                                .AddRequiredParameter("itemId", itemId)
+                                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,164 +127,323 @@ partial void ProcessDeleteByDatabaseIdDetailviewsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdDetailviewsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                itemId: itemId,
-                timestamp: timestamp);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdDetailviewsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    itemId: itemId,
+                    timestamp: timestamp);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdDetailviewsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdDetailviews",
+                                methodName: "DeleteByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdDetailviews",
+                                methodName: "DeleteByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdDetailviews",
+                                methodName: "DeleteByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdDetailviewsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdDetailviews",
+                                methodName: "DeleteByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdDetailviews",
+                                methodName: "DeleteByDatabaseIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/detailviews/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdPurchases.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdPurchases.g.cs
index e3e95b8..2b5037b 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdPurchases.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdPurchases.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,6 +50,7 @@ partial void ProcessDeleteByDatabaseIdPurchasesResponse(
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdPurchasesAsync(
@@ -56,6 +58,7 @@ partial void ProcessDeleteByDatabaseIdPurchasesResponse(
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -73,27 +76,48 @@ partial void ProcessDeleteByDatabaseIdPurchasesResponse(
                 securityRequirements: s_DeleteByDatabaseIdPurchasesSecurityRequirements,
                 operationName: "DeleteByDatabaseIdPurchasesAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/purchases/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddRequiredParameter("userId", userId)
-                .AddRequiredParameter("itemId", itemId)
-                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/purchases/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddRequiredParameter("userId", userId)
+                                .AddRequiredParameter("itemId", itemId)
+                                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,164 +127,323 @@ partial void ProcessDeleteByDatabaseIdPurchasesResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdPurchasesRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                itemId: itemId,
-                timestamp: timestamp);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdPurchasesRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    itemId: itemId,
+                    timestamp: timestamp);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdPurchasesResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdPurchases",
+                                methodName: "DeleteByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdPurchases",
+                                methodName: "DeleteByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdPurchases",
+                                methodName: "DeleteByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdPurchasesResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdPurchases",
+                                methodName: "DeleteByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdPurchases",
+                                methodName: "DeleteByDatabaseIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/purchases/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdRatings.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdRatings.g.cs
index 623d5e5..1d01c88 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdRatings.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdRatings.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,6 +50,7 @@ partial void ProcessDeleteByDatabaseIdRatingsResponse(
         /// <param name="userId"></param>
         /// <param name="itemId"></param>
         /// <param name="timestamp"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdRatingsAsync(
@@ -56,6 +58,7 @@ partial void ProcessDeleteByDatabaseIdRatingsResponse(
             string userId,
             string itemId,
             double? timestamp = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -73,27 +76,48 @@ partial void ProcessDeleteByDatabaseIdRatingsResponse(
                 securityRequirements: s_DeleteByDatabaseIdRatingsSecurityRequirements,
                 operationName: "DeleteByDatabaseIdRatingsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/ratings/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddRequiredParameter("userId", userId)
-                .AddRequiredParameter("itemId", itemId)
-                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/ratings/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddRequiredParameter("userId", userId)
+                                .AddRequiredParameter("itemId", itemId)
+                                .AddOptionalParameter("timestamp", timestamp?.ToString()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,164 +127,323 @@ partial void ProcessDeleteByDatabaseIdRatingsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdRatingsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                itemId: itemId,
-                timestamp: timestamp);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdRatingsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    itemId: itemId,
+                    timestamp: timestamp);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdRatingsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdRatings",
+                                methodName: "DeleteByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdRatings",
+                                methodName: "DeleteByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdRatings",
+                                methodName: "DeleteByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdRatingsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdRatings",
+                                methodName: "DeleteByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdRatings",
+                                methodName: "DeleteByDatabaseIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/ratings/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdViewportions.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdViewportions.g.cs
index d64f2a0..3948fc9 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdViewportions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.DeleteByDatabaseIdViewportions.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,6 +50,7 @@ partial void ProcessDeleteByDatabaseIdViewportionsResponse(
         /// <param name="userId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdViewportionsAsync(
@@ -56,6 +58,7 @@ partial void ProcessDeleteByDatabaseIdViewportionsResponse(
             string userId,
             string itemId,
             string? sessionId = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -73,27 +76,48 @@ partial void ProcessDeleteByDatabaseIdViewportionsResponse(
                 securityRequirements: s_DeleteByDatabaseIdViewportionsSecurityRequirements,
                 operationName: "DeleteByDatabaseIdViewportionsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/viewportions/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddRequiredParameter("userId", userId)
-                .AddRequiredParameter("itemId", itemId)
-                .AddOptionalParameter("sessionId", sessionId) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/viewportions/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddRequiredParameter("userId", userId)
+                                .AddRequiredParameter("itemId", itemId)
+                                .AddOptionalParameter("sessionId", sessionId) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -103,164 +127,323 @@ partial void ProcessDeleteByDatabaseIdViewportionsResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdViewportionsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                itemId: itemId,
-                sessionId: sessionId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdViewportionsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    itemId: itemId,
+                    sessionId: sessionId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdViewportionsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdViewportions",
+                                methodName: "DeleteByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdViewportions",
+                                methodName: "DeleteByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdViewportions",
+                                methodName: "DeleteByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdViewportionsResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdViewportions",
+                                methodName: "DeleteByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdViewportions",
+                                methodName: "DeleteByDatabaseIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/viewportions/\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdBookmarks.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdBookmarks.g.cs
index fe57719..6f52aac 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdBookmarks.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdBookmarks.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdItemsByItemIdBookmarksResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Bookmark>> GetByDatabaseIdItemsByItemIdBookmarksAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdItemsByItemIdBookmarksResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsByItemIdBookmarksSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsByItemIdBookmarksAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}/bookmarks/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}/bookmarks/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdItemsByItemIdBookmarksResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsByItemIdBookmarksRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsByItemIdBookmarksRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsByItemIdBookmarksResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdBookmarks",
+                                methodName: "GetByDatabaseIdItemsByItemIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdBookmarks",
+                                methodName: "GetByDatabaseIdItemsByItemIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdBookmarks",
+                                methodName: "GetByDatabaseIdItemsByItemIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsByItemIdBookmarksResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsByItemIdBookmarksResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Bookmark>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Bookmark>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdBookmarks",
+                                methodName: "GetByDatabaseIdItemsByItemIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdBookmarks",
+                                methodName: "GetByDatabaseIdItemsByItemIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Bookmark>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Bookmark>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsByItemIdBookmarksResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Bookmark>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Bookmark>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Bookmark>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Bookmark>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdCartadditions.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdCartadditions.g.cs
index 021cdd8..1d40ae6 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdCartadditions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdCartadditions.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdItemsByItemIdCartadditionsResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.CartAddition>> GetByDatabaseIdItemsByItemIdCartadditionsAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdItemsByItemIdCartadditionsResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsByItemIdCartadditionsSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsByItemIdCartadditionsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}/cartadditions/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}/cartadditions/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdItemsByItemIdCartadditionsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsByItemIdCartadditionsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsByItemIdCartadditionsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsByItemIdCartadditionsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdCartadditions",
+                                methodName: "GetByDatabaseIdItemsByItemIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdCartadditions",
+                                methodName: "GetByDatabaseIdItemsByItemIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdCartadditions",
+                                methodName: "GetByDatabaseIdItemsByItemIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsByItemIdCartadditionsResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsByItemIdCartadditionsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.CartAddition>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.CartAddition>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdCartadditions",
+                                methodName: "GetByDatabaseIdItemsByItemIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdCartadditions",
+                                methodName: "GetByDatabaseIdItemsByItemIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.CartAddition>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.CartAddition>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsByItemIdCartadditionsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.CartAddition>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.CartAddition>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.CartAddition>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.CartAddition>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdDetailviews.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdDetailviews.g.cs
index 27606b2..fc9133f 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdDetailviews.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdDetailviews.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdItemsByItemIdDetailviewsResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.DetailView>> GetByDatabaseIdItemsByItemIdDetailviewsAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdItemsByItemIdDetailviewsResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsByItemIdDetailviewsSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsByItemIdDetailviewsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}/detailviews/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}/detailviews/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdItemsByItemIdDetailviewsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsByItemIdDetailviewsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsByItemIdDetailviewsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsByItemIdDetailviewsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdDetailviews",
+                                methodName: "GetByDatabaseIdItemsByItemIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdDetailviews",
+                                methodName: "GetByDatabaseIdItemsByItemIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdDetailviews",
+                                methodName: "GetByDatabaseIdItemsByItemIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsByItemIdDetailviewsResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsByItemIdDetailviewsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.DetailView>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.DetailView>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdDetailviews",
+                                methodName: "GetByDatabaseIdItemsByItemIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdDetailviews",
+                                methodName: "GetByDatabaseIdItemsByItemIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.DetailView>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.DetailView>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsByItemIdDetailviewsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.DetailView>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.DetailView>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.DetailView>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.DetailView>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdPurchases.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdPurchases.g.cs
index 1c11012..b013cd1 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdPurchases.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdPurchases.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdItemsByItemIdPurchasesResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Purchase>> GetByDatabaseIdItemsByItemIdPurchasesAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdItemsByItemIdPurchasesResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsByItemIdPurchasesSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsByItemIdPurchasesAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}/purchases/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}/purchases/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdItemsByItemIdPurchasesResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsByItemIdPurchasesRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsByItemIdPurchasesRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsByItemIdPurchasesResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdPurchases",
+                                methodName: "GetByDatabaseIdItemsByItemIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdPurchases",
+                                methodName: "GetByDatabaseIdItemsByItemIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdPurchases",
+                                methodName: "GetByDatabaseIdItemsByItemIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsByItemIdPurchasesResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsByItemIdPurchasesResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Purchase>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Purchase>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdPurchases",
+                                methodName: "GetByDatabaseIdItemsByItemIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdPurchases",
+                                methodName: "GetByDatabaseIdItemsByItemIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Purchase>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Purchase>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsByItemIdPurchasesResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Purchase>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Purchase>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Purchase>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Purchase>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdRatings.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdRatings.g.cs
index f8439f9..8bff8d0 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdRatings.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdRatings.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdItemsByItemIdRatingsResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Rating>> GetByDatabaseIdItemsByItemIdRatingsAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdItemsByItemIdRatingsResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsByItemIdRatingsSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsByItemIdRatingsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}/ratings/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}/ratings/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdItemsByItemIdRatingsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsByItemIdRatingsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsByItemIdRatingsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsByItemIdRatingsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdRatings",
+                                methodName: "GetByDatabaseIdItemsByItemIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdRatings",
+                                methodName: "GetByDatabaseIdItemsByItemIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdRatings",
+                                methodName: "GetByDatabaseIdItemsByItemIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsByItemIdRatingsResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsByItemIdRatingsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Rating>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Rating>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdRatings",
+                                methodName: "GetByDatabaseIdItemsByItemIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdRatings",
+                                methodName: "GetByDatabaseIdItemsByItemIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Rating>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Rating>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsByItemIdRatingsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Rating>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Rating>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Rating>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Rating>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdViewportions.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdViewportions.g.cs
index 816af68..7b852f6 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdViewportions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdItemsByItemIdViewportions.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdItemsByItemIdViewportionsResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="itemId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.ViewPortion>> GetByDatabaseIdItemsByItemIdViewportionsAsync(
             string databaseId,
             string itemId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdItemsByItemIdViewportionsResponseContent(
                 securityRequirements: s_GetByDatabaseIdItemsByItemIdViewportionsSecurityRequirements,
                 operationName: "GetByDatabaseIdItemsByItemIdViewportionsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/items/{itemId}/viewportions/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/items/{itemId}/viewportions/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdItemsByItemIdViewportionsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdItemsByItemIdViewportionsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                itemId: itemId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdItemsByItemIdViewportionsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    itemId: itemId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdItemsByItemIdViewportionsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdViewportions",
+                                methodName: "GetByDatabaseIdItemsByItemIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdViewportions",
+                                methodName: "GetByDatabaseIdItemsByItemIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdViewportions",
+                                methodName: "GetByDatabaseIdItemsByItemIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdItemsByItemIdViewportionsResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdItemsByItemIdViewportionsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.ViewPortion>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.ViewPortion>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdViewportions",
+                                methodName: "GetByDatabaseIdItemsByItemIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdItemsByItemIdViewportions",
+                                methodName: "GetByDatabaseIdItemsByItemIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/items/{itemId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.ViewPortion>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.ViewPortion>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdItemsByItemIdViewportionsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.ViewPortion>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.ViewPortion>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.ViewPortion>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.ViewPortion>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdBookmarks.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdBookmarks.g.cs
index 7041f4f..ec460e5 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdBookmarks.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdBookmarks.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdUsersByUserIdBookmarksResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Bookmark>> GetByDatabaseIdUsersByUserIdBookmarksAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdUsersByUserIdBookmarksResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersByUserIdBookmarksSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersByUserIdBookmarksAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}/bookmarks/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}/bookmarks/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdUsersByUserIdBookmarksResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersByUserIdBookmarksRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersByUserIdBookmarksRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersByUserIdBookmarksResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdBookmarks",
+                                methodName: "GetByDatabaseIdUsersByUserIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdBookmarks",
+                                methodName: "GetByDatabaseIdUsersByUserIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdBookmarks",
+                                methodName: "GetByDatabaseIdUsersByUserIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersByUserIdBookmarksResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersByUserIdBookmarksResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Bookmark>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Bookmark>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdBookmarks",
+                                methodName: "GetByDatabaseIdUsersByUserIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdBookmarks",
+                                methodName: "GetByDatabaseIdUsersByUserIdBookmarksAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/bookmarks/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Bookmark>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Bookmark>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersByUserIdBookmarksResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Bookmark>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Bookmark>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Bookmark>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Bookmark>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdCartadditions.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdCartadditions.g.cs
index 086d38f..99fa362 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdCartadditions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdCartadditions.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdUsersByUserIdCartadditionsResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.CartAddition>> GetByDatabaseIdUsersByUserIdCartadditionsAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdUsersByUserIdCartadditionsResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersByUserIdCartadditionsSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersByUserIdCartadditionsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}/cartadditions/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}/cartadditions/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdUsersByUserIdCartadditionsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersByUserIdCartadditionsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersByUserIdCartadditionsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersByUserIdCartadditionsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdCartadditions",
+                                methodName: "GetByDatabaseIdUsersByUserIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdCartadditions",
+                                methodName: "GetByDatabaseIdUsersByUserIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdCartadditions",
+                                methodName: "GetByDatabaseIdUsersByUserIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersByUserIdCartadditionsResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersByUserIdCartadditionsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.CartAddition>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.CartAddition>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdCartadditions",
+                                methodName: "GetByDatabaseIdUsersByUserIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdCartadditions",
+                                methodName: "GetByDatabaseIdUsersByUserIdCartadditionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/cartadditions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.CartAddition>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.CartAddition>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersByUserIdCartadditionsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.CartAddition>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.CartAddition>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.CartAddition>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.CartAddition>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdDetailviews.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdDetailviews.g.cs
index f730c1b..00fc3da 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdDetailviews.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdDetailviews.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdUsersByUserIdDetailviewsResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.DetailView>> GetByDatabaseIdUsersByUserIdDetailviewsAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdUsersByUserIdDetailviewsResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersByUserIdDetailviewsSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersByUserIdDetailviewsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}/detailviews/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}/detailviews/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdUsersByUserIdDetailviewsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersByUserIdDetailviewsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersByUserIdDetailviewsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersByUserIdDetailviewsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdDetailviews",
+                                methodName: "GetByDatabaseIdUsersByUserIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdDetailviews",
+                                methodName: "GetByDatabaseIdUsersByUserIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdDetailviews",
+                                methodName: "GetByDatabaseIdUsersByUserIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersByUserIdDetailviewsResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersByUserIdDetailviewsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.DetailView>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.DetailView>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdDetailviews",
+                                methodName: "GetByDatabaseIdUsersByUserIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdDetailviews",
+                                methodName: "GetByDatabaseIdUsersByUserIdDetailviewsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/detailviews/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.DetailView>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.DetailView>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersByUserIdDetailviewsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.DetailView>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.DetailView>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.DetailView>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.DetailView>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdPurchases.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdPurchases.g.cs
index 490072a..68e6e1e 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdPurchases.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdPurchases.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdUsersByUserIdPurchasesResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Purchase>> GetByDatabaseIdUsersByUserIdPurchasesAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdUsersByUserIdPurchasesResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersByUserIdPurchasesSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersByUserIdPurchasesAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}/purchases/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}/purchases/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdUsersByUserIdPurchasesResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersByUserIdPurchasesRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersByUserIdPurchasesRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersByUserIdPurchasesResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdPurchases",
+                                methodName: "GetByDatabaseIdUsersByUserIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdPurchases",
+                                methodName: "GetByDatabaseIdUsersByUserIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdPurchases",
+                                methodName: "GetByDatabaseIdUsersByUserIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersByUserIdPurchasesResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersByUserIdPurchasesResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Purchase>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Purchase>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdPurchases",
+                                methodName: "GetByDatabaseIdUsersByUserIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdPurchases",
+                                methodName: "GetByDatabaseIdUsersByUserIdPurchasesAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/purchases/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Purchase>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Purchase>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersByUserIdPurchasesResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Purchase>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Purchase>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Purchase>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Purchase>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdRatings.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdRatings.g.cs
index ccf0acb..e419440 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdRatings.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdRatings.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdUsersByUserIdRatingsResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.Rating>> GetByDatabaseIdUsersByUserIdRatingsAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdUsersByUserIdRatingsResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersByUserIdRatingsSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersByUserIdRatingsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}/ratings/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}/ratings/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdUsersByUserIdRatingsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersByUserIdRatingsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersByUserIdRatingsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersByUserIdRatingsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdRatings",
+                                methodName: "GetByDatabaseIdUsersByUserIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdRatings",
+                                methodName: "GetByDatabaseIdUsersByUserIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdRatings",
+                                methodName: "GetByDatabaseIdUsersByUserIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersByUserIdRatingsResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersByUserIdRatingsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Rating>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Rating>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdRatings",
+                                methodName: "GetByDatabaseIdUsersByUserIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdRatings",
+                                methodName: "GetByDatabaseIdUsersByUserIdRatingsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/ratings/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.Rating>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Rating>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersByUserIdRatingsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Rating>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Rating>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.Rating>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.Rating>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdViewportions.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdViewportions.g.cs
index 48352c3..5e8df88 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdViewportions.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.GetByDatabaseIdUsersByUserIdViewportions.g.cs
@@ -14,6 +14,7 @@ public partial class UserItemInteractionsClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdUsersByUserIdViewportionsResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.ViewPortion>> GetByDatabaseIdUsersByUserIdViewportionsAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdUsersByUserIdViewportionsResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersByUserIdViewportionsSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersByUserIdViewportionsAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}/viewportions/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}/viewportions/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdUsersByUserIdViewportionsResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersByUserIdViewportionsRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersByUserIdViewportionsRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersByUserIdViewportionsResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdViewportions",
+                                methodName: "GetByDatabaseIdUsersByUserIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdViewportions",
+                                methodName: "GetByDatabaseIdUsersByUserIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdViewportions",
+                                methodName: "GetByDatabaseIdUsersByUserIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersByUserIdViewportionsResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersByUserIdViewportionsResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.ViewPortion>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.ViewPortion>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdViewportions",
+                                methodName: "GetByDatabaseIdUsersByUserIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserIdViewportions",
+                                methodName: "GetByDatabaseIdUsersByUserIdViewportionsAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}/viewportions/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.ViewPortion>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.ViewPortion>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersByUserIdViewportionsResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.ViewPortion>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.ViewPortion>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.ViewPortion>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.ViewPortion>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.g.cs b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.g.cs
index d66954c..c9eb2d6 100644
--- a/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserItemInteractionsClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class UserItemInteractionsClient : global::Recombee.IUserI
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public UserItemInteractionsClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the UserItemInteractionsClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 UserItemInteractionsClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.CreateByDatabaseIdUsersByUserId.g.cs b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.CreateByDatabaseIdUsersByUserId.g.cs
index bc94f39..1efbc13 100644
--- a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.CreateByDatabaseIdUsersByUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.CreateByDatabaseIdUsersByUserId.g.cs
@@ -14,6 +14,7 @@ public partial class UserPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -49,6 +50,7 @@ partial void ProcessCreateByDatabaseIdUsersByUserIdResponse(
         /// <param name="userId"></param>
         /// <param name="cascadeCreate"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task CreateByDatabaseIdUsersByUserIdAsync(
@@ -57,6 +59,7 @@ partial void ProcessCreateByDatabaseIdUsersByUserIdResponse(
 
             string request,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             request = request ?? throw new global::System.ArgumentNullException(nameof(request));
@@ -76,25 +79,46 @@ partial void ProcessCreateByDatabaseIdUsersByUserIdResponse(
                 securityRequirements: s_CreateByDatabaseIdUsersByUserIdSecurityRequirements,
                 operationName: "CreateByDatabaseIdUsersByUserIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddOptionalParameter("cascadeCreate", cascadeCreate?.ToString().ToLowerInvariant()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Post,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddOptionalParameter("cascadeCreate", cascadeCreate?.ToString().ToLowerInvariant()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Post,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -104,170 +128,329 @@ partial void ProcessCreateByDatabaseIdUsersByUserIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
-            var __httpRequestContentBody = global::System.Text.Json.JsonSerializer.Serialize(request, request.GetType(), JsonSerializerContext);
-            var __httpRequestContent = new global::System.Net.Http.StringContent(
-                content: __httpRequestContentBody,
-                encoding: global::System.Text.Encoding.UTF8,
-                mediaType: "application/json");
-            __httpRequest.Content = __httpRequestContent;
+                            var __httpRequestContentBody = global::System.Text.Json.JsonSerializer.Serialize(request, request.GetType(), JsonSerializerContext);
+                            var __httpRequestContent = new global::System.Net.Http.StringContent(
+                                content: __httpRequestContentBody,
+                                encoding: global::System.Text.Encoding.UTF8,
+                                mediaType: "application/json");
+                            __httpRequest.Content = __httpRequestContent;
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareCreateByDatabaseIdUsersByUserIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId,
-                cascadeCreate: cascadeCreate,
-                request: request);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareCreateByDatabaseIdUsersByUserIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId,
+                    cascadeCreate: cascadeCreate,
+                    request: request);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessCreateByDatabaseIdUsersByUserIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdUsersByUserId",
+                                methodName: "CreateByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdUsersByUserId",
+                                methodName: "CreateByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdUsersByUserId",
+                                methodName: "CreateByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessCreateByDatabaseIdUsersByUserIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdUsersByUserId",
+                                methodName: "CreateByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "createByDatabaseIdUsersByUserId",
+                                methodName: "CreateByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "POST",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.DeleteByDatabaseIdUsersPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.DeleteByDatabaseIdUsersPropertiesByPropertyName.g.cs
index be760c6..5ff7b4a 100644
--- a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.DeleteByDatabaseIdUsersPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.DeleteByDatabaseIdUsersPropertiesByPropertyName.g.cs
@@ -14,6 +14,7 @@ public partial class UserPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,11 +44,13 @@ partial void ProcessDeleteByDatabaseIdUsersPropertiesByPropertyNameResponse(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdUsersPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -63,22 +66,43 @@ partial void ProcessDeleteByDatabaseIdUsersPropertiesByPropertyNameResponse(
                 securityRequirements: s_DeleteByDatabaseIdUsersPropertiesByPropertyNameSecurityRequirements,
                 operationName: "DeleteByDatabaseIdUsersPropertiesByPropertyNameAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/properties/{propertyName}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/properties/{propertyName}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -88,162 +112,321 @@ partial void ProcessDeleteByDatabaseIdUsersPropertiesByPropertyNameResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdUsersPropertiesByPropertyNameRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                propertyName: propertyName);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdUsersPropertiesByPropertyNameRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    propertyName: propertyName);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdUsersPropertiesByPropertyNameResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdUsersPropertiesByPropertyNameResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "DeleteByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersByUserId.g.cs b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersByUserId.g.cs
index 4d09cfd..678f08f 100644
--- a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersByUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersByUserId.g.cs
@@ -14,6 +14,7 @@ public partial class UserPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdUsersByUserIdResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<string> GetByDatabaseIdUsersByUserIdAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdUsersByUserIdResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersByUserIdSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersByUserIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,175 +117,334 @@ partial void ProcessGetByDatabaseIdUsersByUserIdResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersByUserIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersByUserIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersByUserIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserId",
+                                methodName: "GetByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserId",
+                                methodName: "GetByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserId",
+                                methodName: "GetByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersByUserIdResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersByUserIdResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return __content;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserId",
+                                methodName: "GetByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersByUserId",
+                                methodName: "GetByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return __content;
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersByUserIdResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return __content;
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return __content;
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersPropertiesByPropertyName.g.cs
index ff7ba98..ea6da49 100644
--- a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersPropertiesByPropertyName.g.cs
@@ -14,6 +14,7 @@ public partial class UserPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -48,11 +49,13 @@ partial void ProcessGetByDatabaseIdUsersPropertiesByPropertyNameResponseContent(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::Recombee.PropertyInfo> GetByDatabaseIdUsersPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,22 +71,43 @@ partial void ProcessGetByDatabaseIdUsersPropertiesByPropertyNameResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersPropertiesByPropertyNameSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersPropertiesByPropertyNameAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/properties/{propertyName}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/properties/{propertyName}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -93,179 +117,338 @@ partial void ProcessGetByDatabaseIdUsersPropertiesByPropertyNameResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersPropertiesByPropertyNameRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                propertyName: propertyName);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersPropertiesByPropertyNameRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    propertyName: propertyName);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersPropertiesByPropertyNameResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                catch (global::System.Exception __ex)
-                {
-                    __exception_400 = __ex;
-                }
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
-                {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersPropertiesByPropertyNameResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersPropertiesByPropertyNameResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        global::Recombee.PropertyInfo.FromJson(__content, JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "GetByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                    return
-                        await global::Recombee.PropertyInfo.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
+
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersPropertiesByPropertyNameResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        global::Recombee.PropertyInfo.FromJson(__content, JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        await global::Recombee.PropertyInfo.FromJsonStreamAsync(__content, JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersPropertiesList.g.cs b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersPropertiesList.g.cs
index 73cc312..10bc4be 100644
--- a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersPropertiesList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.GetByDatabaseIdUsersPropertiesList.g.cs
@@ -14,6 +14,7 @@ public partial class UserPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -45,10 +46,12 @@ partial void ProcessGetByDatabaseIdUsersPropertiesListResponseContent(
         /// Gets the list of all the user properties in your database.
         /// </summary>
         /// <param name="databaseId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>> GetByDatabaseIdUsersPropertiesListAsync(
             string databaseId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -63,22 +66,43 @@ partial void ProcessGetByDatabaseIdUsersPropertiesListResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersPropertiesListSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersPropertiesListAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/properties/list/",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/properties/list/",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -88,145 +112,304 @@ partial void ProcessGetByDatabaseIdUsersPropertiesListResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersPropertiesListRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersPropertiesListRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersPropertiesListResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 404)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesList",
+                                methodName: "GetByDatabaseIdUsersPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
+                    {
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesList",
+                                methodName: "GetByDatabaseIdUsersPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesList",
+                                methodName: "GetByDatabaseIdUsersPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersPropertiesListResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersPropertiesListResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesList",
+                                methodName: "GetByDatabaseIdUsersPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersPropertiesList",
+                                methodName: "GetByDatabaseIdUsersPropertiesListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersPropertiesListResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.PropertyInfo>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.PutByDatabaseIdUsersPropertiesByPropertyName.g.cs b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.PutByDatabaseIdUsersPropertiesByPropertyName.g.cs
index f98f8cc..db5f8c2 100644
--- a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.PutByDatabaseIdUsersPropertiesByPropertyName.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.PutByDatabaseIdUsersPropertiesByPropertyName.g.cs
@@ -14,6 +14,7 @@ public partial class UserPropertiesClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -46,12 +47,14 @@ partial void ProcessPutByDatabaseIdUsersPropertiesByPropertyNameResponse(
         /// <param name="databaseId"></param>
         /// <param name="propertyName"></param>
         /// <param name="type"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdUsersPropertiesByPropertyNameAsync(
             string databaseId,
             string propertyName,
             global::Recombee.PutUsersPropertiesType type,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -68,25 +71,46 @@ partial void ProcessPutByDatabaseIdUsersPropertiesByPropertyNameResponse(
                 securityRequirements: s_PutByDatabaseIdUsersPropertiesByPropertyNameSecurityRequirements,
                 operationName: "PutByDatabaseIdUsersPropertiesByPropertyNameAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/properties/{propertyName}",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddRequiredParameter("type", type.ToValueString()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/properties/{propertyName}",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddRequiredParameter("type", type.ToValueString()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -96,163 +120,322 @@ partial void ProcessPutByDatabaseIdUsersPropertiesByPropertyNameResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdUsersPropertiesByPropertyNameRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                propertyName: propertyName,
-                type: type);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdUsersPropertiesByPropertyNameRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    propertyName: propertyName,
+                    type: type);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdUsersPropertiesByPropertyNameResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessPutByDatabaseIdUsersPropertiesByPropertyNameResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersPropertiesByPropertyName",
+                                methodName: "PutByDatabaseIdUsersPropertiesByPropertyNameAsync",
+                                pathTemplate: "$\"/{databaseId}/users/properties/{propertyName}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.g.cs b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.g.cs
index cf7c9c6..8227657 100644
--- a/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UserPropertiesClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class UserPropertiesClient : global::Recombee.IUserPropert
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public UserPropertiesClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the UserPropertiesClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 UserPropertiesClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);
diff --git a/src/libs/Recombee/Generated/Recombee.UsersClient.DeleteByDatabaseIdUsersByUserId.g.cs b/src/libs/Recombee/Generated/Recombee.UsersClient.DeleteByDatabaseIdUsersByUserId.g.cs
index e726b07..52a0f17 100644
--- a/src/libs/Recombee/Generated/Recombee.UsersClient.DeleteByDatabaseIdUsersByUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UsersClient.DeleteByDatabaseIdUsersByUserId.g.cs
@@ -14,6 +14,7 @@ public partial class UsersClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -44,11 +45,13 @@ partial void ProcessDeleteByDatabaseIdUsersByUserIdResponse(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task DeleteByDatabaseIdUsersByUserIdAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -64,22 +67,43 @@ partial void ProcessDeleteByDatabaseIdUsersByUserIdResponse(
                 securityRequirements: s_DeleteByDatabaseIdUsersByUserIdSecurityRequirements,
                 operationName: "DeleteByDatabaseIdUsersByUserIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Delete,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Delete,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -89,162 +113,321 @@ partial void ProcessDeleteByDatabaseIdUsersByUserIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareDeleteByDatabaseIdUsersByUserIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareDeleteByDatabaseIdUsersByUserIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessDeleteByDatabaseIdUsersByUserIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersByUserId",
+                                methodName: "DeleteByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersByUserId",
+                                methodName: "DeleteByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersByUserId",
+                                methodName: "DeleteByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessDeleteByDatabaseIdUsersByUserIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersByUserId",
+                                methodName: "DeleteByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "deleteByDatabaseIdUsersByUserId",
+                                methodName: "DeleteByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "DELETE",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UsersClient.GetByDatabaseIdUsersList.g.cs b/src/libs/Recombee/Generated/Recombee.UsersClient.GetByDatabaseIdUsersList.g.cs
index eb4a113..c570746 100644
--- a/src/libs/Recombee/Generated/Recombee.UsersClient.GetByDatabaseIdUsersList.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UsersClient.GetByDatabaseIdUsersList.g.cs
@@ -14,6 +14,7 @@ public partial class UsersClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -60,6 +61,7 @@ partial void ProcessGetByDatabaseIdUsersListResponseContent(
         /// <param name="offset"></param>
         /// <param name="returnProperties"></param>
         /// <param name="includedProperties"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task<global::System.Collections.Generic.IList<global::Recombee.User>> GetByDatabaseIdUsersListAsync(
@@ -69,6 +71,7 @@ partial void ProcessGetByDatabaseIdUsersListResponseContent(
             int? offset = default,
             bool? returnProperties = default,
             global::System.Collections.Generic.IList<string>? includedProperties = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -88,29 +91,50 @@ partial void ProcessGetByDatabaseIdUsersListResponseContent(
                 securityRequirements: s_GetByDatabaseIdUsersListSecurityRequirements,
                 operationName: "GetByDatabaseIdUsersListAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/list/",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddOptionalParameter("filter", filter)
-                .AddOptionalParameter("count", count?.ToString())
-                .AddOptionalParameter("offset", offset?.ToString())
-                .AddOptionalParameter("returnProperties", returnProperties?.ToString().ToLowerInvariant())
-                .AddOptionalParameter("includedProperties", includedProperties, delimiter: ",", explode: false) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Get,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/list/",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddOptionalParameter("filter", filter)
+                                .AddOptionalParameter("count", count?.ToString())
+                                .AddOptionalParameter("offset", offset?.ToString())
+                                .AddOptionalParameter("returnProperties", returnProperties?.ToString().ToLowerInvariant())
+                                .AddOptionalParameter("includedProperties", includedProperties, delimiter: ",", explode: false) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Get,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -120,150 +144,309 @@ partial void ProcessGetByDatabaseIdUsersListResponseContent(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PrepareGetByDatabaseIdUsersListRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                filter: filter,
-                count: count,
-                offset: offset,
-                returnProperties: returnProperties,
-                includedProperties: includedProperties);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PrepareGetByDatabaseIdUsersListRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    filter: filter,
+                    count: count,
+                    offset: offset,
+                    returnProperties: returnProperties,
+                    includedProperties: includedProperties);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessGetByDatabaseIdUsersListResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 404)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersList",
+                                methodName: "GetByDatabaseIdUsersListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                    }
+                    catch (global::System.Net.Http.HttpRequestException __exception)
+                    {
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersList",
+                                methodName: "GetByDatabaseIdUsersListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
-                    else
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
                     {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersList",
+                                methodName: "GetByDatabaseIdUsersListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_404 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
 
-                ProcessResponseContent(
+                ProcessResponse(
                     client: HttpClient,
-                    response: __response,
-                    content: ref __content);
-                ProcessGetByDatabaseIdUsersListResponseContent(
+                    response: __response);
+                ProcessGetByDatabaseIdUsersListResponse(
                     httpClient: HttpClient,
-                    httpResponseMessage: __response,
-                    content: ref __content);
-
-                try
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    __response.EnsureSuccessStatusCode();
-
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.User>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.User>), JsonSerializerContext) ??
-                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersList",
+                                methodName: "GetByDatabaseIdUsersListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "getByDatabaseIdUsersList",
+                                methodName: "GetByDatabaseIdUsersListAsync",
+                                pathTemplate: "$\"/{databaseId}/users/list/\"",
+                                httpMethod: "GET",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-            }
-            else
-            {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                    using var __content = await __response.Content.ReadAsStreamAsync(
-#if NET5_0_OR_GREATER
-                        cancellationToken
-#endif
-                    ).ConfigureAwait(false);
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-                    return
-                        (global::System.Collections.Generic.IList<global::Recombee.User>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.User>), JsonSerializerContext).ConfigureAwait(false) ??
-                        throw new global::System.InvalidOperationException("Response deserialization failed.");
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
+
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+                                ProcessGetByDatabaseIdUsersListResponseContent(
+                                    httpClient: HttpClient,
+                                    httpResponseMessage: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.User>?)global::System.Text.Json.JsonSerializer.Deserialize(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.User>), JsonSerializerContext) ??
+                                        throw new global::System.InvalidOperationException($"Response deserialization failed for \"{__content}\" ");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                    using var __content = await __response.Content.ReadAsStreamAsync(
+                #if NET5_0_OR_GREATER
+                                        __effectiveCancellationToken
+                #endif
+                                    ).ConfigureAwait(false);
+
+                                    return
+                                        (global::System.Collections.Generic.IList<global::Recombee.User>?)await global::System.Text.Json.JsonSerializer.DeserializeAsync(__content, typeof(global::System.Collections.Generic.IList<global::Recombee.User>), JsonSerializerContext).ConfigureAwait(false) ??
+                                        throw new global::System.InvalidOperationException("Response deserialization failed.");
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
+            finally
+            {
+                __httpRequest?.Dispose();
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/src/libs/Recombee/Generated/Recombee.UsersClient.PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserId.g.cs b/src/libs/Recombee/Generated/Recombee.UsersClient.PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserId.g.cs
index b7533b7..f78174b 100644
--- a/src/libs/Recombee/Generated/Recombee.UsersClient.PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UsersClient.PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserId.g.cs
@@ -14,6 +14,7 @@ public partial class UsersClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -52,6 +53,7 @@ partial void ProcessPutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdRespons
         /// <param name="targetUserId"></param>
         /// <param name="sourceUserId"></param>
         /// <param name="cascadeCreate"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdAsync(
@@ -59,6 +61,7 @@ partial void ProcessPutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdRespons
             string targetUserId,
             string sourceUserId,
             bool? cascadeCreate = default,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -76,25 +79,46 @@ partial void ProcessPutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdRespons
                 securityRequirements: s_PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdSecurityRequirements,
                 operationName: "PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{targetUserId}/merge/{sourceUserId}",
-                baseUri: HttpClient.BaseAddress); 
-            __pathBuilder
-                .AddOptionalParameter("cascadeCreate", cascadeCreate?.ToString().ToLowerInvariant()) 
-                ;
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{targetUserId}/merge/{sourceUserId}",
+                                baseUri: HttpClient.BaseAddress); 
+                            __pathBuilder
+                                .AddOptionalParameter("cascadeCreate", cascadeCreate?.ToString().ToLowerInvariant()) 
+                                ;
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -104,164 +128,323 @@ partial void ProcessPutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdRespons
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                targetUserId: targetUserId,
-                sourceUserId: sourceUserId,
-                cascadeCreate: cascadeCreate);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    targetUserId: targetUserId,
+                    sourceUserId: sourceUserId,
+                    cascadeCreate: cascadeCreate);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByTargetUserIdMergeBySourceUserId",
+                                methodName: "PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{targetUserId}/merge/{sourceUserId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByTargetUserIdMergeBySourceUserId",
+                                methodName: "PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{targetUserId}/merge/{sourceUserId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByTargetUserIdMergeBySourceUserId",
+                                methodName: "PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{targetUserId}/merge/{sourceUserId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 404)
-            {
-                string? __content_404 = null;
-                global::System.Exception? __exception_404 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessPutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_404 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByTargetUserIdMergeBySourceUserId",
+                                methodName: "PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{targetUserId}/merge/{sourceUserId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_404 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByTargetUserIdMergeBySourceUserId",
+                                methodName: "PutByDatabaseIdUsersByTargetUserIdMergeBySourceUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{targetUserId}/merge/{sourceUserId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_404,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_404,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 404)
+                            {
+                                string? __content_404 = null;
+                                global::System.Exception? __exception_404 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_404 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_404 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_404 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_404,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_404,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UsersClient.PutByDatabaseIdUsersByUserId.g.cs b/src/libs/Recombee/Generated/Recombee.UsersClient.PutByDatabaseIdUsersByUserId.g.cs
index d3d9bdb..9069955 100644
--- a/src/libs/Recombee/Generated/Recombee.UsersClient.PutByDatabaseIdUsersByUserId.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UsersClient.PutByDatabaseIdUsersByUserId.g.cs
@@ -14,6 +14,7 @@ public partial class UsersClient
                 {                    new global::Recombee.EndPointAuthorizationRequirement
                     {
                         Type = "Http",
+                        SchemeId = "HttpBearer",
                         Location = "Header",
                         Name = "Bearer",
                         FriendlyName = "Bearer",
@@ -43,11 +44,13 @@ partial void ProcessPutByDatabaseIdUsersByUserIdResponse(
         /// </summary>
         /// <param name="databaseId"></param>
         /// <param name="userId"></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::Recombee.ApiException"></exception>
         public async global::System.Threading.Tasks.Task PutByDatabaseIdUsersByUserIdAsync(
             string databaseId,
             string userId,
+            global::Recombee.AutoSDKRequestOptions? requestOptions = default,
             global::System.Threading.CancellationToken cancellationToken = default)
         {
             PrepareArguments(
@@ -63,22 +66,43 @@ partial void ProcessPutByDatabaseIdUsersByUserIdResponse(
                 securityRequirements: s_PutByDatabaseIdUsersByUserIdSecurityRequirements,
                 operationName: "PutByDatabaseIdUsersByUserIdAsync");
 
-            var __pathBuilder = new global::Recombee.PathBuilder(
-                path: $"/{databaseId}/users/{userId}",
-                baseUri: HttpClient.BaseAddress);
-            var __path = __pathBuilder.ToString();
-            using var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
-                method: global::System.Net.Http.HttpMethod.Put,
-                requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
+            using var __timeoutCancellationTokenSource = global::Recombee.AutoSDKRequestOptionsSupport.CreateTimeoutCancellationTokenSource(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                cancellationToken: cancellationToken);
+            var __effectiveCancellationToken = __timeoutCancellationTokenSource?.Token ?? cancellationToken;
+            var __effectiveReadResponseAsString = global::Recombee.AutoSDKRequestOptionsSupport.GetReadResponseAsString(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                fallbackValue: ReadResponseAsString);
+            var __maxAttempts = global::Recombee.AutoSDKRequestOptionsSupport.GetMaxAttempts(
+                clientOptions: Options,
+                requestOptions: requestOptions,
+                supportsRetry: true);
+
+            global::System.Net.Http.HttpRequestMessage __CreateHttpRequest()
+            {
+                            var __pathBuilder = new global::Recombee.PathBuilder(
+                                path: $"/{databaseId}/users/{userId}",
+                                baseUri: HttpClient.BaseAddress);
+                            var __path = __pathBuilder.ToString();
+                __path = global::Recombee.AutoSDKRequestOptionsSupport.AppendQueryParameters(
+                    path: __path,
+                    clientParameters: Options.QueryParameters,
+                    requestParameters: requestOptions?.QueryParameters);
+                var __httpRequest = new global::System.Net.Http.HttpRequestMessage(
+                    method: global::System.Net.Http.HttpMethod.Put,
+                    requestUri: new global::System.Uri(__path, global::System.UriKind.RelativeOrAbsolute));
 #if NET6_0_OR_GREATER
-            __httpRequest.Version = global::System.Net.HttpVersion.Version11;
-            __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
+                __httpRequest.Version = global::System.Net.HttpVersion.Version11;
+                __httpRequest.VersionPolicy = global::System.Net.Http.HttpVersionPolicy.RequestVersionOrHigher;
 #endif
 
             foreach (var __authorization in __authorizations)
             {
                 if (__authorization.Type == "Http" ||
-                    __authorization.Type == "OAuth2")
+                    __authorization.Type == "OAuth2" ||
+                    __authorization.Type == "OpenIdConnect")
                 {
                     __httpRequest.Headers.Authorization = new global::System.Net.Http.Headers.AuthenticationHeaderValue(
                         scheme: __authorization.Name,
@@ -88,162 +112,321 @@ partial void ProcessPutByDatabaseIdUsersByUserIdResponse(
                          __authorization.Location == "Header")
                 {
                     __httpRequest.Headers.Add(__authorization.Name, __authorization.Value);
-                }
+                } 
             }
+                global::Recombee.AutoSDKRequestOptionsSupport.ApplyHeaders(
+                    request: __httpRequest,
+                    clientHeaders: Options.Headers,
+                    requestHeaders: requestOptions?.Headers);
 
-            PrepareRequest(
-                client: HttpClient,
-                request: __httpRequest);
-            PreparePutByDatabaseIdUsersByUserIdRequest(
-                httpClient: HttpClient,
-                httpRequestMessage: __httpRequest,
-                databaseId: databaseId,
-                userId: userId);
+                PrepareRequest(
+                    client: HttpClient,
+                    request: __httpRequest);
+                PreparePutByDatabaseIdUsersByUserIdRequest(
+                    httpClient: HttpClient,
+                    httpRequestMessage: __httpRequest,
+                    databaseId: databaseId,
+                    userId: userId);
 
-            using var __response = await HttpClient.SendAsync(
-                request: __httpRequest,
-                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
-                cancellationToken: cancellationToken).ConfigureAwait(false);
+                return __httpRequest;
+            }
 
-            ProcessResponse(
-                client: HttpClient,
-                response: __response);
-            ProcessPutByDatabaseIdUsersByUserIdResponse(
-                httpClient: HttpClient,
-                httpResponseMessage: __response);
-            // 
-            if ((int)__response.StatusCode == 400)
+            global::System.Net.Http.HttpRequestMessage? __httpRequest = null;
+            global::System.Net.Http.HttpResponseMessage? __response = null;
+            var __attemptNumber = 0;
+            try
             {
-                string? __content_400 = null;
-                global::System.Exception? __exception_400 = null;
-                try
+                for (var __attempt = 1; __attempt <= __maxAttempts; __attempt++)
                 {
-                    if (ReadResponseAsString)
+                    __attemptNumber = __attempt;
+                    __httpRequest = __CreateHttpRequest();
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnBeforeRequestAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByUserId",
+                                methodName: "PutByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                    try
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        __response = await HttpClient.SendAsync(
+                request: __httpRequest,
+                completionOption: global::System.Net.Http.HttpCompletionOption.ResponseContentRead,
+                cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
                     }
-                    else
+                    catch (global::System.Net.Http.HttpRequestException __exception)
                     {
-                        __content_400 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
+                        var __willRetry = __attempt < __maxAttempts && !__effectiveCancellationToken.IsCancellationRequested;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByUserId",
+                                methodName: "PutByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: null,
+                                exception: __exception,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: __willRetry,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        if (!__willRetry)
+                        {
+                            throw;
+                        }
+
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
                     }
+
+                    if (__response != null &&
+                        __attempt < __maxAttempts &&
+                        global::Recombee.AutoSDKRequestOptionsSupport.ShouldRetryStatusCode(__response.StatusCode))
+                    {
+                        await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByUserId",
+                                methodName: "PutByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attempt,
+                                maxAttempts: __maxAttempts,
+                                willRetry: true,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
+                        __response.Dispose();
+                        __response = null;
+                        __httpRequest.Dispose();
+                        __httpRequest = null;
+                        await global::Recombee.AutoSDKRequestOptionsSupport.DelayBeforeRetryAsync(
+                            clientOptions: Options,
+                            requestOptions: requestOptions,
+                            cancellationToken: __effectiveCancellationToken).ConfigureAwait(false);
+                        continue;
+                    }
+
+                    break;
                 }
-                catch (global::System.Exception __ex)
+
+                if (__response == null)
                 {
-                    __exception_400 = __ex;
+                    throw new global::System.InvalidOperationException("No response received.");
                 }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_400,
-                    statusCode: __response.StatusCode)
+                using (__response)
                 {
-                    ResponseBody = __content_400,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
-            // 
-            if ((int)__response.StatusCode == 409)
-            {
-                string? __content_409 = null;
-                global::System.Exception? __exception_409 = null;
-                try
+
+                ProcessResponse(
+                    client: HttpClient,
+                    response: __response);
+                ProcessPutByDatabaseIdUsersByUserIdResponse(
+                    httpClient: HttpClient,
+                    httpResponseMessage: __response);
+                if (__response.IsSuccessStatusCode)
                 {
-                    if (ReadResponseAsString)
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        __content_409 = await __response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
-                    }
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterSuccessAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByUserId",
+                                methodName: "PutByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
-                catch (global::System.Exception __ex)
+                else
                 {
-                    __exception_409 = __ex;
+                    await global::Recombee.AutoSDKRequestOptionsSupport.OnAfterErrorAsync(
+                            clientOptions: Options,
+                            context: global::Recombee.AutoSDKRequestOptionsSupport.CreateHookContext(
+                                operationId: "putByDatabaseIdUsersByUserId",
+                                methodName: "PutByDatabaseIdUsersByUserIdAsync",
+                                pathTemplate: "$\"/{databaseId}/users/{userId}\"",
+                                httpMethod: "PUT",
+                                baseUri: BaseUri,
+                                request: __httpRequest!,
+                                response: __response,
+                                exception: null,
+                                clientOptions: Options,
+                                requestOptions: requestOptions,
+                                attempt: __attemptNumber,
+                                maxAttempts: __maxAttempts,
+                                willRetry: false,
+                                cancellationToken: __effectiveCancellationToken)).ConfigureAwait(false);
                 }
+                            // 
+                            if ((int)__response.StatusCode == 400)
+                            {
+                                string? __content_400 = null;
+                                global::System.Exception? __exception_400 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_400 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_400 = __ex;
+                                }
 
-                throw new global::Recombee.ApiException(
-                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
-                    innerException: __exception_409,
-                    statusCode: __response.StatusCode)
-                {
-                    ResponseBody = __content_409,
-                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                        __response.Headers,
-                        h => h.Key,
-                        h => h.Value),
-                };
-            }
+                                throw new global::Recombee.ApiException(
+                                    message: __content_400 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_400,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_400,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
+                            // 
+                            if ((int)__response.StatusCode == 409)
+                            {
+                                string? __content_409 = null;
+                                global::System.Exception? __exception_409 = null;
+                                try
+                                {
+                                    if (__effectiveReadResponseAsString)
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                    else
+                                    {
+                                        __content_409 = await __response.Content.ReadAsStringAsync(__effectiveCancellationToken).ConfigureAwait(false);
+                                    }
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    __exception_409 = __ex;
+                                }
 
-            if (ReadResponseAsString)
-            {
-                var __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                    cancellationToken
-#endif
-                ).ConfigureAwait(false);
+                                throw new global::Recombee.ApiException(
+                                    message: __content_409 ?? __response.ReasonPhrase ?? string.Empty,
+                                    innerException: __exception_409,
+                                    statusCode: __response.StatusCode)
+                                {
+                                    ResponseBody = __content_409,
+                                    ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                        __response.Headers,
+                                        h => h.Key,
+                                        h => h.Value),
+                                };
+                            }
 
-                ProcessResponseContent(
-                    client: HttpClient,
-                    response: __response,
-                    content: ref __content);
+                            if (__effectiveReadResponseAsString)
+                            {
+                                var __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                    __effectiveCancellationToken
+                #endif
+                                ).ConfigureAwait(false);
 
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
+                                ProcessResponseContent(
+                                    client: HttpClient,
+                                    response: __response,
+                                    content: ref __content);
+
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
+                            else
+                            {
+                                try
+                                {
+                                    __response.EnsureSuccessStatusCode();
+                                }
+                                catch (global::System.Exception __ex)
+                                {
+                                    string? __content = null;
+                                    try
+                                    {
+                                        __content = await __response.Content.ReadAsStringAsync(
+                #if NET5_0_OR_GREATER
+                                            __effectiveCancellationToken
+                #endif
+                                        ).ConfigureAwait(false);
+                                    }
+                                    catch (global::System.Exception)
+                                    {
+                                    }
+
+                                    throw new global::Recombee.ApiException(
+                                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
+                                        innerException: __ex,
+                                        statusCode: __response.StatusCode)
+                                    {
+                                        ResponseBody = __content,
+                                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
+                                            __response.Headers,
+                                            h => h.Key,
+                                            h => h.Value),
+                                    };
+                                }
+                            }
 
-                }
-                catch (global::System.Exception __ex)
-                {
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
                 }
             }
-            else
+            finally
             {
-                try
-                {
-                    __response.EnsureSuccessStatusCode();
-                }
-                catch (global::System.Exception __ex)
-                {
-                    string? __content = null;
-                    try
-                    {
-                        __content = await __response.Content.ReadAsStringAsync(
-#if NET5_0_OR_GREATER
-                            cancellationToken
-#endif
-                        ).ConfigureAwait(false);
-                    }
-                    catch (global::System.Exception)
-                    {
-                    }
-
-                    throw new global::Recombee.ApiException(
-                        message: __content ?? __response.ReasonPhrase ?? string.Empty,
-                        innerException: __ex,
-                        statusCode: __response.StatusCode)
-                    {
-                        ResponseBody = __content,
-                        ResponseHeaders = global::System.Linq.Enumerable.ToDictionary(
-                            __response.Headers,
-                            h => h.Key,
-                            h => h.Value),
-                    };
-                }
+                __httpRequest?.Dispose();
             }
         }
     }
diff --git a/src/libs/Recombee/Generated/Recombee.UsersClient.g.cs b/src/libs/Recombee/Generated/Recombee.UsersClient.g.cs
index fa4fdf3..d3c4e86 100644
--- a/src/libs/Recombee/Generated/Recombee.UsersClient.g.cs
+++ b/src/libs/Recombee/Generated/Recombee.UsersClient.g.cs
@@ -30,6 +30,9 @@ public sealed partial class UsersClient : global::Recombee.IUsersClient, global:
 #if DEBUG
             = true;
 #endif
+
+        /// <inheritdoc/>
+        public global::Recombee.AutoSDKClientOptions Options { get; }
         /// <summary>
         /// 
         /// </summary>
@@ -49,11 +52,37 @@ public UsersClient(
             global::System.Net.Http.HttpClient? httpClient = null,
             global::System.Uri? baseUri = null,
             global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            bool disposeHttpClient = true) : this(
+                httpClient,
+                baseUri,
+                authorizations,
+                options: null,
+                disposeHttpClient: disposeHttpClient)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the UsersClient.
+        /// If no httpClient is provided, a new one will be created.
+        /// If no baseUri is provided, the default baseUri from OpenAPI spec will be used.
+        /// </summary>
+        /// <param name="httpClient">The HttpClient instance. If not provided, a new one will be created.</param>
+        /// <param name="baseUri">The base URL for the API. If not provided, the default baseUri from OpenAPI spec will be used.</param>
+        /// <param name="authorizations">The authorizations to use for the requests.</param>
+        /// <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 UsersClient(
+            global::System.Net.Http.HttpClient? httpClient = null,
+            global::System.Uri? baseUri = null,
+            global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>? authorizations = null,
+            global::Recombee.AutoSDKClientOptions? options = null,
             bool disposeHttpClient = true)
         {
+
             HttpClient = httpClient ?? new global::System.Net.Http.HttpClient();
             HttpClient.BaseAddress ??= baseUri ?? new global::System.Uri(DefaultBaseUrl);
             Authorizations = authorizations ?? new global::System.Collections.Generic.List<global::Recombee.EndPointAuthorization>();
+            Options = options ?? new global::Recombee.AutoSDKClientOptions();
             _disposeHttpClient = disposeHttpClient;
 
             Initialized(HttpClient);