public Task <TraktNoContentResponse> RevokeAuthorizationAsync(string accessToken, string clientId, string clientSecret, CancellationToken cancellationToken = default)
        {
            var request = new AuthorizationRevokeRequest
            {
                RequestBody = new AuthorizationRevokeRequestBody
                {
                    AccessToken  = accessToken,
                    ClientId     = clientId,
                    ClientSecret = clientSecret
                }
            };

            var requestHandler = new AuthenticationRequestHandler(Client);

            return(requestHandler.RevokeAuthorizationAsync(request, cancellationToken));
        }
        public async Task <TraktNoContentResponse> RevokeAuthorizationAsync(AuthorizationRevokeRequest request, CancellationToken cancellationToken = default)
        {
            try
            {
                request.Validate();

                ExtendedHttpRequestMessage requestMessage =
                    await _requestMessageBuilder.Reset(request)
                    .WithRequestBody(request.RequestBody)
                    .DisableAPIVersionHeader()
                    .DisableAPIClientIdHeader()
                    .Build().ConfigureAwait(false);

                HttpResponseMessage responseMessage = await _client.HttpClientProvider.GetHttpClient().SendAsync(requestMessage, cancellationToken).ConfigureAwait(false);

                if (!responseMessage.IsSuccessStatusCode)
                {
                    if (responseMessage.StatusCode == HttpStatusCode.Unauthorized)
                    {
                        string responseContent = responseMessage.Content != null ? await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false) : string.Empty;

                        throw new TraktAuthenticationException("error on revoking access token")
                              {
                                  RequestUrl         = requestMessage.Url,
                                  RequestBody        = requestMessage.RequestBodyJson,
                                  Response           = responseContent,
                                  ServerReasonPhrase = responseMessage.ReasonPhrase
                              };
                    }

                    await ResponseErrorHandler.HandleErrorsAsync(requestMessage, responseMessage, isAuthorizationRevoke : true, cancellationToken : cancellationToken).ConfigureAwait(false);
                }
                else
                {
                    _client.Authorization = TraktAuthorization.CreateWith(string.Empty, string.Empty);

                    return(new TraktNoContentResponse
                    {
                        IsSuccess = true
                    });
                }

                throw new TraktAuthenticationException("unknown exception")
                      {
                          RequestUrl         = requestMessage.Url,
                          RequestBody        = requestMessage.RequestBodyJson,
                          StatusCode         = responseMessage.StatusCode,
                          ServerReasonPhrase = responseMessage.ReasonPhrase
                      };
            }
            catch (Exception ex)
            {
                if (_client.Configuration.ThrowResponseExceptions)
                {
                    throw;
                }

                return(new TraktNoContentResponse {
                    IsSuccess = false, Exception = ex
                });
            }
        }