public ResponseWithHeaders <MessageIdDeleteHeaders> Delete(string messageid, string popReceipt, int?timeout = null, CancellationToken cancellationToken = default) { if (messageid == null) { throw new ArgumentNullException(nameof(messageid)); } if (popReceipt == null) { throw new ArgumentNullException(nameof(popReceipt)); } using var message = CreateDeleteRequest(messageid, popReceipt, timeout); _pipeline.Send(message, cancellationToken); var headers = new MessageIdDeleteHeaders(message.Response); switch (message.Response.Status) { case 204: return(ResponseWithHeaders.FromValue(headers, message.Response)); default: throw _clientDiagnostics.CreateRequestFailedException(message.Response); } }
public ResponseWithHeaders <ContainerRegistryBlobUploadChunkHeaders> UploadChunk(string nextLink, Stream value, CancellationToken cancellationToken = default) { if (nextLink == null) { throw new ArgumentNullException(nameof(nextLink)); } if (value == null) { throw new ArgumentNullException(nameof(value)); } using var message = CreateUploadChunkRequest(nextLink, value); _pipeline.Send(message, cancellationToken); var headers = new ContainerRegistryBlobUploadChunkHeaders(message.Response); switch (message.Response.Status) { case 202: return(ResponseWithHeaders.FromValue(headers, message.Response)); default: throw _clientDiagnostics.CreateRequestFailedException(message.Response); } }
public ResponseWithHeaders <BlobDeleteHeaders> Delete(string containerName, string blob, int?timeout = null, string leaseId = null, DeleteSnapshotsOptionType?deleteSnapshots = null, DateTimeOffset?ifModifiedSince = null, DateTimeOffset?ifUnmodifiedSince = null, string ifMatch = null, string ifNoneMatch = null, string ifTags = null, BlobDeleteType?blobDeleteType = null, CancellationToken cancellationToken = default) { if (containerName == null) { throw new ArgumentNullException(nameof(containerName)); } if (blob == null) { throw new ArgumentNullException(nameof(blob)); } using var message = CreateDeleteRequest(containerName, blob, timeout, leaseId, deleteSnapshots, ifModifiedSince, ifUnmodifiedSince, ifMatch, ifNoneMatch, ifTags, blobDeleteType); _pipeline.Send(message, cancellationToken); var headers = new BlobDeleteHeaders(message.Response); switch (message.Response.Status) { case 202: return(ResponseWithHeaders.FromValue(headers, message.Response)); default: throw ClientDiagnostics.CreateRequestFailedException(message.Response); } }
public ResponseWithHeaders <PhoneNumbersSearchAvailablePhoneNumbersHeaders> SearchAvailablePhoneNumbers(string countryCode, PhoneNumberSearchRequest body, CancellationToken cancellationToken = default) { if (countryCode == null) { throw new ArgumentNullException(nameof(countryCode)); } if (body == null) { throw new ArgumentNullException(nameof(body)); } using var message = CreateSearchAvailablePhoneNumbersRequest(countryCode, body); _pipeline.Send(message, cancellationToken); var headers = new PhoneNumbersSearchAvailablePhoneNumbersHeaders(message.Response); switch (message.Response.Status) { case 202: return(ResponseWithHeaders.FromValue(headers, message.Response)); default: throw _clientDiagnostics.CreateRequestFailedException(message.Response); } }
public virtual Response <ExtractedReceipt> ExtractReceipt(Uri uri, bool includeRawPageExtractions = false, CancellationToken cancellationToken = default) { SourcePath_internal sourcePath = new SourcePath_internal() { Source = uri.ToString() }; ResponseWithHeaders <AnalyzeReceiptAsyncHeaders> response = _operations.RestClient.AnalyzeReceiptAsync(includeTextDetails: includeRawPageExtractions, sourcePath, cancellationToken); var operation = new ExtractReceiptOperation(_operations, response.Headers.OperationLocation); ValueTask <Response <ExtractedReceipt> > task = operation.WaitForCompletionAsync(); // TODO: this feels very bad. Better way? // https://github.com/Azure/azure-sdk-for-net/issues/10391 task.AsTask().Wait(); if (!operation.HasValue) { throw new RequestFailedException("Failed to retrieve response from ExtractReceipt Long-Running Operation"); } // TODO: this is also a mess. Reconcile these together. // https://github.com/Azure/azure-sdk-for-net/issues/10391 return(Response.FromValue(operation.Value, task.AsTask().Result.GetRawResponse())); }
/// <summary> /// Trains a model from a collection of custom forms in a blob storage container. /// </summary> /// <param name="trainingFilesUri">An externally accessible Azure storage blob container Uri. /// For more information see <a href="https://docs.microsoft.com/azure/cognitive-services/form-recognizer/build-training-data-set#upload-your-training-data"/>.</param> /// <param name="useTrainingLabels">If <c>true</c>, use a label file created in the <link-to-label-tool-doc> to provide training-time labels for training a model. If <c>false</c>, the model will be trained from forms only.</param> /// <param name="trainingOptions">A set of options available for configuring the training request.</param> /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param> /// <returns> /// <para>A <see cref="TrainingOperation"/> to wait on this long-running operation. Its <see cref="TrainingOperation.Value"/> upon successful /// completion will contain meta-data about the trained model.</para> /// <para>Even if training fails, a model is created in the Form Recognizer account with an "invalid" status. /// A <see cref="RequestFailedException"/> will be raised containing the modelId to access this invalid model.</para> /// </returns> public virtual TrainingOperation StartTraining(Uri trainingFilesUri, bool useTrainingLabels, TrainingOptions trainingOptions = default, CancellationToken cancellationToken = default) { Argument.AssertNotNull(trainingFilesUri, nameof(trainingFilesUri)); trainingOptions ??= new TrainingOptions(); using DiagnosticScope scope = Diagnostics.CreateScope($"{nameof(FormTrainingClient)}.{nameof(StartTraining)}"); scope.Start(); try { var trainRequest = new TrainRequest(trainingFilesUri.AbsoluteUri) { SourceFilter = trainingOptions.TrainingFileFilter, UseLabelFile = useTrainingLabels }; ResponseWithHeaders <ServiceTrainCustomModelAsyncHeaders> response = ServiceClient.TrainCustomModelAsync(trainRequest); return(new TrainingOperation(response.Headers.Location, ServiceClient, Diagnostics)); } catch (Exception e) { scope.Failed(e); throw; } }
public async Task <ResponseWithHeaders <Stream, SchemaGetByIdHeaders> > GetByIdAsync(string schemaId, CancellationToken cancellationToken = default) { if (schemaId == null) { throw new ArgumentNullException(nameof(schemaId)); } using var message = CreateGetByIdRequest(schemaId); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); var headers = new SchemaGetByIdHeaders(message.Response); switch (message.Response.Status) { case 200: { var value = message.ExtractResponseContent(); return(ResponseWithHeaders.FromValue(value, headers, message.Response)); } default: throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false); } }
public ResponseWithHeaders <string, SchemaGetByIdHeaders> GetById(string schemaId, CancellationToken cancellationToken = default) { if (schemaId == null) { throw new ArgumentNullException(nameof(schemaId)); } using var message = CreateGetByIdRequest(schemaId); _pipeline.Send(message, cancellationToken); var headers = new SchemaGetByIdHeaders(message.Response); switch (message.Response.Status) { case 200: { StreamReader streamReader = new StreamReader(message.Response.ContentStream); string value = streamReader.ReadToEnd(); return(ResponseWithHeaders.FromValue(value, headers, message.Response)); } default: throw _clientDiagnostics.CreateRequestFailedException(message.Response); } }
public ResponseWithHeaders <ContainerRegistryBlobCompleteUploadHeaders> CompleteUpload(string digest, string location, Stream value = null, CancellationToken cancellationToken = default) { if (digest == null) { throw new ArgumentNullException(nameof(digest)); } if (location == null) { throw new ArgumentNullException(nameof(location)); } using var message = CreateCompleteUploadRequest(digest, location, value); _pipeline.Send(message, cancellationToken); var headers = new ContainerRegistryBlobCompleteUploadHeaders(message.Response); switch (message.Response.Status) { case 201: return(ResponseWithHeaders.FromValue(headers, message.Response)); default: throw _clientDiagnostics.CreateRequestFailedException(message.Response); } }
public async Task <ResponseWithHeaders <QueueServiceStatistics, ServiceGetStatisticsHeaders> > GetStatisticsAsync(int?timeout = null, CancellationToken cancellationToken = default) { using var message = CreateGetStatisticsRequest(timeout); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); var headers = new ServiceGetStatisticsHeaders(message.Response); switch (message.Response.Status) { case 200: { QueueServiceStatistics value = default; var document = XDocument.Load(message.Response.ContentStream, LoadOptions.PreserveWhitespace); if (document.Element("StorageServiceStats") is XElement storageServiceStatsElement) { value = QueueServiceStatistics.DeserializeQueueServiceStatistics(storageServiceStatsElement); } return(ResponseWithHeaders.FromValue(value, headers, message.Response)); } default: throw await ClientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false); } }
public async ValueTask <ResponseWithHeaders <TableServiceProperties, ServiceGetPropertiesHeaders> > GetPropertiesAsync(int?timeout = null, string requestId = null, CancellationToken cancellationToken = default) { using var message = CreateGetPropertiesRequest(timeout, requestId); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); var headers = new ServiceGetPropertiesHeaders(message.Response); switch (message.Response.Status) { case 200: { TableServiceProperties value = default; var document = XDocument.Load(message.Response.ContentStream, LoadOptions.PreserveWhitespace); if (document.Element("TableServiceProperties") is XElement tableServicePropertiesElement) { value = TableServiceProperties.DeserializeTableServiceProperties(tableServicePropertiesElement); } return(ResponseWithHeaders.FromValue(value, headers, message.Response)); } default: throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false); } }
public async Task <ResponseWithHeaders <ListQueuesSegmentResponse, ServiceListQueuesSegmentHeaders> > ListQueuesSegmentAsync(string prefix = null, string marker = null, int?maxresults = null, IEnumerable <string> include = null, int?timeout = null, CancellationToken cancellationToken = default) { using var message = CreateListQueuesSegmentRequest(prefix, marker, maxresults, include, timeout); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); var headers = new ServiceListQueuesSegmentHeaders(message.Response); switch (message.Response.Status) { case 200: { ListQueuesSegmentResponse value = default; var document = XDocument.Load(message.Response.ContentStream, LoadOptions.PreserveWhitespace); if (document.Element("EnumerationResults") is XElement enumerationResultsElement) { value = ListQueuesSegmentResponse.DeserializeListQueuesSegmentResponse(enumerationResultsElement); } return(ResponseWithHeaders.FromValue(value, headers, message.Response)); } default: throw await ClientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(false); } }
public async ValueTask <ResponseWithHeaders <TableQueryResponse, TableInternalQueryHeaders> > QueryAsync(string requestId = null, QueryOptions queryOptions = null, CancellationToken cancellationToken = default) { using var message = CreateQueryRequest(requestId, queryOptions); await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); var headers = new TableInternalQueryHeaders(message.Response); switch (message.Response.Status) { case 200: { TableQueryResponse value = default; using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false); if (document.RootElement.ValueKind == JsonValueKind.Null) { value = null; } else { value = TableQueryResponse.DeserializeTableQueryResponse(document.RootElement); } return(ResponseWithHeaders.FromValue(value, headers, message.Response)); }
/// <summary> /// Get the status results for all submitted translation operations. /// </summary> /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param> public virtual AsyncPageable <TranslationStatusResult> GetTranslationsAsync(CancellationToken cancellationToken = default) { async Task <Page <TranslationStatusResult> > FirstPageFunc(int?pageSizeHint) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(DocumentTranslationClient)}.{nameof(GetTranslations)}"); scope.Start(); try { ResponseWithHeaders <BatchStatusResponse, DocumentTranslationGetOperationsHeaders> response = await _serviceRestClient.GetOperationsAsync(cancellationToken : cancellationToken).ConfigureAwait(false); return(Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse())); } catch (Exception e) { scope.Failed(e); throw; } } async Task <Page <TranslationStatusResult> > NextPageFunc(string nextLink, int?pageSizeHint) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(DocumentTranslationClient)}.{nameof(GetTranslations)}"); scope.Start(); try { Response <BatchStatusResponse> response = await _serviceRestClient.GetOperationsNextPageAsync(nextLink, cancellationToken : cancellationToken).ConfigureAwait(false); return(Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse())); } catch (Exception e) { scope.Failed(e); throw; } } return(PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, NextPageFunc)); }
/// <summary> /// Initializes a new instance of a RestoreOperation. /// </summary> /// <param name="client">An instance of <see cref="KeyVaultBackupClient" />.</param> /// <param name="response">The <see cref="ResponseWithHeaders{T, THeaders}" /> returned from <see cref="KeyVaultBackupClient.StartRestore"/> or <see cref="KeyVaultBackupClient.StartRestoreAsync"/>.</param> /// <exception cref="ArgumentNullException"><paramref name="client"/> or <paramref name="response"/> is null.</exception> internal RestoreOperation(KeyVaultBackupClient client, ResponseWithHeaders <AzureSecurityKeyVaultAdministrationFullRestoreOperationHeaders> response) { _operationInternal = new RestoreOperationInternal <AzureSecurityKeyVaultAdministrationFullRestoreOperationHeaders, RestoreResult, RestoreDetailsInternal>(client, response); }
/// <summary> Insert entity in a table. </summary> /// <param name="async">Determines whether execution will occur asynchronously.</param> /// <param name="table"> The name of the table. </param> /// <param name="timeout"> The The timeout parameter is expressed in seconds. For more information, see <a href="https://docs.microsoft.com/en-us/rest/api/storageservices/setting-timeouts-for-queue-service-operations>Setting Timeouts for Queue Service Operations.</a>. </param> /// <param name="requestId"> Provides a client-generated, opaque value with a 1 KB character limit that is recorded in the analytics logs when storage analytics logging is enabled. </param> /// <param name="tableEntityProperties"> The properties for the table entity. </param> /// <param name="queryOptions"> Parameter group. </param> /// <param name="cancellationToken"> The cancellation token to use. </param> private async ValueTask <ResponseWithHeaders <ReadOnlyDictionary <string, object>, TableInternalInsertEntityHeaders> > InsertEntityInternalAsync(bool async, string table, int?timeout = null, string requestId = null, IDictionary <string, object> tableEntityProperties = null, QueryOptions queryOptions = null, CancellationToken cancellationToken = default) { if (table == null) { throw new ArgumentNullException(nameof(table)); } using var scope = _clientDiagnostics.CreateScope("TableInternalClient.InsertEntity"); scope.Start(); try { using var message = CreateInsertEntityRequest(table, timeout, requestId, tableEntityProperties, queryOptions); if (async) { await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false); } else { _pipeline.Send(message, cancellationToken); } var headers = new TableInternalInsertEntityHeaders(message.Response); switch (message.Response.Status) { case 201: { Dictionary <string, object> value = default; JsonDocument document; if (async) { document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false); } else { document = JsonDocument.Parse(message.Response.ContentStream); } using (document) { if (document.RootElement.ValueKind == JsonValueKind.Null) { value = null; } else { Dictionary <string, object> dictionary = new Dictionary <string, object>(); foreach (var property in document.RootElement.EnumerateObject()) { if (property.Value.ValueKind == JsonValueKind.Null) { dictionary.Add(property.Name, null); } else { dictionary.Add(property.Name, property.Value.GetObject()); } } value = dictionary; } return(ResponseWithHeaders.FromValue(new ReadOnlyDictionary <string, object>(value), headers, message.Response)); } }
/// <summary> /// Get the list of the document formats supported by the Document Translation service. /// </summary> /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param> public virtual async Task<Response<IReadOnlyList<DocumentTranslationFileFormat>>> GetSupportedDocumentFormatsAsync(CancellationToken cancellationToken = default) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(DocumentTranslationClient)}.{nameof(GetSupportedDocumentFormats)}"); scope.Start(); try { ResponseWithHeaders<SupportedFileFormats, DocumentTranslationGetSupportedDocumentFormatsHeaders> response = await _serviceRestClient.GetSupportedDocumentFormatsAsync(cancellationToken).ConfigureAwait(false); return Response.FromValue(response.Value.Value, response.GetRawResponse()); } catch (Exception e) { scope.Failed(e); throw; } }
/// <summary> /// Get the list of the glossary formats supported by the Document Translation service. /// </summary> /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param> public virtual Response <IReadOnlyList <FileFormat> > GetGlossaryFormats(CancellationToken cancellationToken = default) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(DocumentTranslationClient)}.{nameof(GetGlossaryFormats)}"); scope.Start(); try { ResponseWithHeaders <SupportedFileFormats, DocumentTranslationGetSupportedGlossaryFormatsHeaders> response = _serviceRestClient.GetSupportedGlossaryFormats(cancellationToken); return(Response.FromValue(response.Value.Value, response.GetRawResponse())); } catch (Exception e) { scope.Failed(e); throw; } }
/// <summary> /// Get the status results for all submitted translation operations. /// </summary> /// <param name="cancellationToken">A <see cref="CancellationToken"/> controlling the request lifetime.</param> public virtual Pageable <TranslationStatusResult> GetTranslations(CancellationToken cancellationToken = default) { Page <TranslationStatusResult> FirstPageFunc(int?pageSizeHint) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(DocumentTranslationClient)}.{nameof(GetTranslations)}"); scope.Start(); try { ResponseWithHeaders <TranslationsStatus, DocumentTranslationGetTranslationsStatusHeaders> response = _serviceRestClient.GetTranslationsStatus(cancellationToken: cancellationToken); return(Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse())); } catch (Exception e) { scope.Failed(e); throw; } } Page <TranslationStatusResult> NextPageFunc(string nextLink, int?pageSizeHint) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(DocumentTranslationClient)}.{nameof(GetTranslations)}"); scope.Start(); try { ResponseWithHeaders <TranslationsStatus, DocumentTranslationGetTranslationsStatusHeaders> response = _serviceRestClient.GetTranslationsStatusNextPage(nextLink, cancellationToken: cancellationToken); return(Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse())); } catch (Exception e) { scope.Failed(e); throw; } } return(PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc)); }
/// <summary> /// Gets the status of an Object Anchors asset conversion job. /// </summary> /// <param name="JobId">The asset conversion job's ID.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns><see cref="Response{AssetConversionProperties}"/>.</returns> internal virtual Response <AssetConversionProperties> GetAssetConversionStatus(Guid JobId, CancellationToken cancellationToken = default) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(ObjectAnchorsConversionClient)}.{nameof(GetAssetConversionStatus)}"); scope.Start(); try { ResponseWithHeaders <AssetConversionProperties, IngestionJobGetHeaders> properties = _ingestionJobRestClient .Get(AccountId, JobId, xMrcCv: GenerateCv(), cancellationToken: cancellationToken); properties.Value.JobId = JobId; properties.Value.AccountId = AccountId; return(properties); } catch (Exception ex) { scope.Failed(ex); throw; } }
/// <summary> /// Retrieve a token from the STS service for the specified account identifier asynchronously. /// </summary> /// <param name="cancellationToken">The cancellation token.</param> /// <returns><see cref="Response{AccessToken}"/>.</returns> public virtual async Task <Response <AccessToken> > GetTokenAsync(CancellationToken cancellationToken = default) { MixedRealityTokenRequestOptions headerOptions = MixedRealityTokenRequestOptions.GenerateNew(); using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(MixedRealityStsClient)}.{nameof(GetToken)}"); scope.AddAttribute(nameof(headerOptions.ClientRequestId), headerOptions.ClientRequestId); scope.Start(); try { ResponseWithHeaders <StsTokenResponseMessage, MixedRealityStsGetTokenHeaders> response = await _restClient.GetTokenAsync(AccountId, headerOptions, cancellationToken).ConfigureAwait(false); return(ResponseWithHeaders.FromValue(response.Value.ToAccessToken(), response.Headers, response.GetRawResponse())); } catch (Exception ex) { scope.Failed(ex); throw; } }
/// <summary> List repositories in this registry. </summary> /// <param name="cancellationToken"> The cancellation token to use. </param> /// <exception cref="RequestFailedException">Thrown when a failure is returned by the Container Registry service.</exception> public virtual Pageable <string> GetRepositoryNames(CancellationToken cancellationToken = default) { Page <string> FirstPageFunc(int?pageSizeHint) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(ContainerRegistryClient)}.{nameof(GetRepositoryNames)}"); scope.Start(); try { ResponseWithHeaders <Repositories, ContainerRegistryGetRepositoriesHeaders> response = _restClient.GetRepositories(last: null, n: pageSizeHint, cancellationToken); return(Page.FromValues(response.Value.RepositoriesValue, response.Headers.Link, response.GetRawResponse())); } catch (Exception e) { scope.Failed(e); throw; } } Page <string> NextPageFunc(string continuationToken, int?pageSizeHint) { using DiagnosticScope scope = _clientDiagnostics.CreateScope($"{nameof(ContainerRegistryClient)}.{nameof(GetRepositoryNames)}"); scope.Start(); try { string uriReference = ParseUriReferenceFromLinkHeader(continuationToken); ResponseWithHeaders <Repositories, ContainerRegistryGetRepositoriesHeaders> response = _restClient.GetRepositoriesNextPage(uriReference, last: null, n: null, cancellationToken); return(Page.FromValues(response.Value.RepositoriesValue, response.Headers.Link, response.GetRawResponse())); } catch (Exception e) { scope.Failed(e); throw; } } return(PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc)); }
/// <summary> /// Initializes a new instance of a SelectiveKeyRestoreOperation. /// </summary> /// <param name="client">An instance of <see cref="KeyVaultBackupClient" />.</param> /// <param name="response">The <see cref="ResponseWithHeaders{T, THeaders}" /> returned from <see cref="KeyVaultBackupClient.StartRestore"/> or <see cref="KeyVaultBackupClient.StartRestoreAsync"/>.</param> /// <exception cref="ArgumentNullException"><paramref name="client"/> or <paramref name="response"/> is null.</exception> internal SelectiveKeyRestoreOperation(KeyVaultBackupClient client, ResponseWithHeaders <AzureSecurityKeyVaultAdministrationSelectiveKeyRestoreOperationHeaders> response) { _operationInternal = new RestoreOperationInternal <AzureSecurityKeyVaultAdministrationSelectiveKeyRestoreOperationHeaders, SelectiveKeyRestoreResult>(client, response); }