/// <summary>
        /// Calls the server to get updated status of the long-running operation.
        /// </summary>
        /// <param name="async">When <c>true</c>, the method will be executed asynchronously; otherwise, it will execute synchronously.</param>
        /// <param name="cancellationToken">A <see cref="CancellationToken"/> used for the service call.</param>
        /// <returns>The HTTP response received from the server.</returns>
        private async ValueTask <Response> UpdateStatusAsync(bool async, CancellationToken cancellationToken)
        {
            if (!_hasCompleted)
            {
                using DiagnosticScope scope = _diagnostics.CreateScope($"{nameof(AnalyzeOperation)}.{nameof(UpdateStatus)}");
                scope.Start();

                try
                {
                    Response <AnalyzeJobState> update = async
                        ? await _serviceClient.AnalyzeStatusAsync(Id, _showStats, null, null, cancellationToken).ConfigureAwait(false)
                        : _serviceClient.AnalyzeStatus(Id, _showStats, null, null, cancellationToken);

                    _response = update.GetRawResponse();

                    if (update.Value.Status == TextAnalyticsOperationStatus.Succeeded)
                    {
                        // we need to first assign a vaue and then mark the operation as completed to avoid race conditions
                        _value = Transforms.ConvertToAnalyzeOperationResult(update.Value, _idToIndexMap);

                        NextLink      = update.Value.NextLink;
                        _hasCompleted = true;
                    }
                    else if (update.Value.Status == TextAnalyticsOperationStatus.Failed)
                    {
                        _requestFailedException = await ClientCommon.CreateExceptionForFailedOperationAsync(async, _diagnostics, _response, update.Value.Errors).ConfigureAwait(false);

                        _hasCompleted = true;
                        throw _requestFailedException;
                    }
                }
                catch (Exception e)
                {
                    scope.Failed(e);
                    throw;
                }
            }

            return(GetRawResponse());
        }
        async ValueTask <OperationState <AsyncPageable <AnalyzeHealthcareEntitiesResultCollection> > > IOperation <AsyncPageable <AnalyzeHealthcareEntitiesResultCollection> > .UpdateStateAsync(bool async, CancellationToken cancellationToken)
        {
            Response <HealthcareJobStatusResult> response = async
                ? await _serviceClient.HealthStatusAsync(_jobId, _showStats, null, null, _idToIndexMap, cancellationToken).ConfigureAwait(false)
                : _serviceClient.HealthStatus(_jobId, _showStats, null, null, _idToIndexMap, cancellationToken);

            _createdOn    = response.Value.CreatedOn;
            _expiresOn    = response.Value.ExpiresOn;
            _lastModified = response.Value.LastModifiedOn;
            _status       = response.Value.Status;

            Response rawResponse = response.GetRawResponse();

            if (response.Value.Status == TextAnalyticsOperationStatus.Succeeded)
            {
                string nextLink = response.Value.NextLink;
                _firstPage = Page.FromValues(new List <AnalyzeHealthcareEntitiesResultCollection>()
                {
                    response.Value.Result
                }, nextLink, rawResponse);

                return(OperationState <AsyncPageable <AnalyzeHealthcareEntitiesResultCollection> > .Success(rawResponse, CreateOperationValueAsync(CancellationToken.None)));
            }
            else if (response.Value.Status == TextAnalyticsOperationStatus.Failed)
            {
                RequestFailedException requestFailedException = await ClientCommon
                                                                .CreateExceptionForFailedOperationAsync(async, _diagnostics, rawResponse, response.Value.Errors)
                                                                .ConfigureAwait(false);

                return(OperationState <AsyncPageable <AnalyzeHealthcareEntitiesResultCollection> > .Failure(rawResponse, requestFailedException));
            }
            else if (response.Value.Status == TextAnalyticsOperationStatus.Cancelled)
            {
                return(OperationState <AsyncPageable <AnalyzeHealthcareEntitiesResultCollection> > .Failure(rawResponse,
                                                                                                            new RequestFailedException("The operation was canceled so no value is available.")));
            }

            return(OperationState <AsyncPageable <AnalyzeHealthcareEntitiesResultCollection> > .Pending(rawResponse));
        }