[csharp] Address obsolete build warnings in ApiClient (#19847)

alec-petersen · web-flow · commit b5b760a8a2b0 · 2024-10-14T15:44:12.000+08:00
* Stop using obsolete MaxTimeout

* Convert timeout to a timespan, rather than update the configuration object

* Use async overload of RestClientExtensions.Deserialize

* Update samples

* Fix typo

* Undo timeout change
diff --git a/modules/openapi-generator/src/main/resources/csharp/ApiClient.mustache b/modules/openapi-generator/src/main/resources/csharp/ApiClient.mustache
@@ -550,11 +550,11 @@ namespace {{packageName}}.Client
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -587,7 +587,7 @@ namespace {{packageName}}.Client
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -613,7 +613,7 @@ namespace {{packageName}}.Client
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/echo_api/csharp-restsharp/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/echo_api/csharp-restsharp/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -533,11 +533,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -570,7 +570,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -594,7 +594,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/others/csharp-complex-files/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/others/csharp-complex-files/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -533,11 +533,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -570,7 +570,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -594,7 +594,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/petstore/csharp/restsharp/net4.7/MultipleFrameworks/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net4.7/MultipleFrameworks/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -549,11 +549,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -586,7 +586,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -610,7 +610,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/petstore/csharp/restsharp/net4.7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net4.7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -549,11 +549,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -586,7 +586,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -610,7 +610,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/petstore/csharp/restsharp/net4.8/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net4.8/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -549,11 +549,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -586,7 +586,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -610,7 +610,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/petstore/csharp/restsharp/net6/ParameterMappings/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net6/ParameterMappings/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -532,11 +532,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -569,7 +569,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -593,7 +593,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/petstore/csharp/restsharp/net7/EnumMappings/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net7/EnumMappings/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -548,11 +548,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -585,7 +585,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -609,7 +609,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/petstore/csharp/restsharp/net7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net7/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -548,11 +548,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -585,7 +585,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -609,7 +609,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/petstore/csharp/restsharp/net7/UseDateTimeForDate/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/net7/UseDateTimeForDate/src/Org.OpenAPITools/Client/ApiClient.cs
@@ -532,11 +532,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest
             }
         }
 
-        private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)
+        private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)
         {
             if (policyResult.Outcome == OutcomeType.Successful) 
             {
-                return client.Deserialize<T>(policyResult.Result);
+                return await client.Deserialize<T>(policyResult.Result, cancellationToken);
             }
             else
             {
@@ -569,7 +569,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.RetryPolicy;
                     var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));
-                    return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));
+                    return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);
                 }
                 else
                 {
@@ -593,7 +593,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea
                 {
                     var policy = RetryConfiguration.AsyncRetryPolicy;
                     var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);
-                    return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);
+                    return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);
                 }
                 else
                 {
diff --git a/samples/client/petstore/csharp/restsharp/standard2.0/ConditionalSerialization/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/standard2.0/ConditionalSerialization/src/Org.OpenAPITools/Client/ApiClient.cs
diff --git a/samples/client/petstore/csharp/restsharp/standard2.0/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs b/samples/client/petstore/csharp/restsharp/standard2.0/Petstore/src/Org.OpenAPITools/Client/ApiClient.cs

Original file line number	Diff line number	Diff line change
`@@ -550,11 +550,11 @@ namespace {{packageName}}.Client`
`550`	`550`	`}`
`551`	`551`	`}`
`552`	`552`
`553`		`- private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)`
	`553`	`+ private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)`
`554`	`554`	`{`
`555`	`555`	`if (policyResult.Outcome == OutcomeType.Successful)`
`556`	`556`	`{`
`557`		`- return client.Deserialize<T>(policyResult.Result);`
	`557`	`+ return await client.Deserialize<T>(policyResult.Result, cancellationToken);`
`558`	`558`	`}`
`559`	`559`	`else`
`560`	`560`	`{`
`@@ -587,7 +587,7 @@ namespace {{packageName}}.Client`
`587`	`587`	`{`
`588`	`588`	`var policy = RetryConfiguration.RetryPolicy;`
`589`	`589`	`var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));`
`590`		`- return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));`
	`590`	`+ return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);`
`591`	`591`	`}`
`592`	`592`	`else`
`593`	`593`	`{`
`@@ -613,7 +613,7 @@ namespace {{packageName}}.Client`
`613`	`613`	`{`
`614`	`614`	`var policy = RetryConfiguration.AsyncRetryPolicy;`
`615`	`615`	`var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);`
`616`		`- return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);`
	`616`	`+ return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);`
`617`	`617`	`}`
`618`	`618`	`else`
`619`	`619`	`{`
Original file line number	Diff line number	Diff line change
`@@ -533,11 +533,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest`
`533`	`533`	`}`
`534`	`534`	`}`
`535`	`535`
`536`		`- private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)`
	`536`	`+ private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)`
`537`	`537`	`{`
`538`	`538`	`if (policyResult.Outcome == OutcomeType.Successful)`
`539`	`539`	`{`
`540`		`- return client.Deserialize<T>(policyResult.Result);`
	`540`	`+ return await client.Deserialize<T>(policyResult.Result, cancellationToken);`
`541`	`541`	`}`
`542`	`542`	`else`
`543`	`543`	`{`
`@@ -570,7 +570,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea`
`570`	`570`	`{`
`571`	`571`	`var policy = RetryConfiguration.RetryPolicy;`
`572`	`572`	`var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));`
`573`		`- return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));`
	`573`	`+ return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);`
`574`	`574`	`}`
`575`	`575`	`else`
`576`	`576`	`{`
`@@ -594,7 +594,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea`
`594`	`594`	`{`
`595`	`595`	`var policy = RetryConfiguration.AsyncRetryPolicy;`
`596`	`596`	`var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);`
`597`		`- return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);`
	`597`	`+ return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);`
`598`	`598`	`}`
`599`	`599`	`else`
`600`	`600`	`{`
Original file line number	Diff line number	Diff line change
`@@ -549,11 +549,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest`
`549`	`549`	`}`
`550`	`550`	`}`
`551`	`551`
`552`		`- private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)`
	`552`	`+ private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)`
`553`	`553`	`{`
`554`	`554`	`if (policyResult.Outcome == OutcomeType.Successful)`
`555`	`555`	`{`
`556`		`- return client.Deserialize<T>(policyResult.Result);`
	`556`	`+ return await client.Deserialize<T>(policyResult.Result, cancellationToken);`
`557`	`557`	`}`
`558`	`558`	`else`
`559`	`559`	`{`
`@@ -586,7 +586,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea`
`586`	`586`	`{`
`587`	`587`	`var policy = RetryConfiguration.RetryPolicy;`
`588`	`588`	`var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));`
`589`		`- return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));`
	`589`	`+ return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);`
`590`	`590`	`}`
`591`	`591`	`else`
`592`	`592`	`{`
`@@ -610,7 +610,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea`
`610`	`610`	`{`
`611`	`611`	`var policy = RetryConfiguration.AsyncRetryPolicy;`
`612`	`612`	`var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);`
`613`		`- return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);`
	`613`	`+ return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);`
`614`	`614`	`}`
`615`	`615`	`else`
`616`	`616`	`{`
Original file line number	Diff line number	Diff line change
`@@ -532,11 +532,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest`
`532`	`532`	`}`
`533`	`533`	`}`
`534`	`534`
`535`		`- private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)`
	`535`	`+ private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)`
`536`	`536`	`{`
`537`	`537`	`if (policyResult.Outcome == OutcomeType.Successful)`
`538`	`538`	`{`
`539`		`- return client.Deserialize<T>(policyResult.Result);`
	`539`	`+ return await client.Deserialize<T>(policyResult.Result, cancellationToken);`
`540`	`540`	`}`
`541`	`541`	`else`
`542`	`542`	`{`
`@@ -569,7 +569,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea`
`569`	`569`	`{`
`570`	`570`	`var policy = RetryConfiguration.RetryPolicy;`
`571`	`571`	`var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));`
`572`		`- return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));`
	`572`	`+ return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);`
`573`	`573`	`}`
`574`	`574`	`else`
`575`	`575`	`{`
`@@ -593,7 +593,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea`
`593`	`593`	`{`
`594`	`594`	`var policy = RetryConfiguration.AsyncRetryPolicy;`
`595`	`595`	`var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);`
`596`		`- return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);`
	`596`	`+ return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);`
`597`	`597`	`}`
`598`	`598`	`else`
`599`	`599`	`{`
Original file line number	Diff line number	Diff line change
`@@ -548,11 +548,11 @@ private async Task<ApiResponse<T>> ExecClientAsync<T>(Func<RestClient, Task<Rest`
`548`	`548`	`}`
`549`	`549`	`}`
`550`	`550`
`551`		`- private RestResponse<T> DeserializeRestResponseFromPolicy<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult)`
	`551`	`+ private async Task<RestResponse<T>> DeserializeRestResponseFromPolicyAsync<T>(RestClient client, RestRequest request, PolicyResult<RestResponse> policyResult, CancellationToken cancellationToken = default)`
`552`	`552`	`{`
`553`	`553`	`if (policyResult.Outcome == OutcomeType.Successful)`
`554`	`554`	`{`
`555`		`- return client.Deserialize<T>(policyResult.Result);`
	`555`	`+ return await client.Deserialize<T>(policyResult.Result, cancellationToken);`
`556`	`556`	`}`
`557`	`557`	`else`
`558`	`558`	`{`
`@@ -585,7 +585,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea`
`585`	`585`	`{`
`586`	`586`	`var policy = RetryConfiguration.RetryPolicy;`
`587`	`587`	`var policyResult = policy.ExecuteAndCapture(() => client.Execute(request));`
`588`		`- return Task.FromResult(DeserializeRestResponseFromPolicy<T>(client, request, policyResult));`
	`588`	`+ return DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult);`
`589`	`589`	`}`
`590`	`590`	`else`
`591`	`591`	`{`
`@@ -609,7 +609,7 @@ private ApiResponse<T> Exec<T>(RestRequest request, RequestOptions options, IRea`
`609`	`609`	`{`
`610`	`610`	`var policy = RetryConfiguration.AsyncRetryPolicy;`
`611`	`611`	`var policyResult = await policy.ExecuteAndCaptureAsync((ct) => client.ExecuteAsync(request, ct), cancellationToken).ConfigureAwait(false);`
`612`		`- return DeserializeRestResponseFromPolicy<T>(client, request, policyResult);`
	`612`	`+ return await DeserializeRestResponseFromPolicyAsync<T>(client, request, policyResult, cancellationToken);`
`613`	`613`	`}`
`614`	`614`	`else`
`615`	`615`	`{`