< Summary

Class:Azure.ResourceManager.AppConfiguration.PrivateEndpointConnectionsRestOperations
Assembly:Azure.ResourceManager.AppConfiguration
File(s):C:\Git\azure-sdk-for-net\sdk\appconfiguration\Azure.ResourceManager.AppConfiguration\src\Generated\PrivateEndpointConnectionsRestOperations.cs
Covered lines:157
Uncovered lines:80
Coverable lines:237
Total lines:536
Line coverage:66.2% (157 of 237)
Covered branches:43
Total branches:106
Branch coverage:40.5% (43 of 106)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
.ctor(...)-83.33%50%
CreateListByConfigurationStoreRequest(...)-100%100%
ListByConfigurationStoreAsync()-73.33%50%
ListByConfigurationStore(...)-73.33%50%
CreateGetRequest(...)-100%100%
GetAsync()-70.59%50%
Get(...)-70.59%50%
CreateCreateOrUpdateRequest(...)-100%100%
CreateOrUpdateAsync()-64.29%50%
CreateOrUpdate(...)-64.29%50%
CreateDeleteRequest(...)-100%100%
DeleteAsync()-66.67%50%
Delete(...)-66.67%50%
CreateListByConfigurationStoreNextPageRequest(...)-0%100%
ListByConfigurationStoreNextPageAsync()-0%0%
ListByConfigurationStoreNextPage(...)-0%0%

File(s)

C:\Git\azure-sdk-for-net\sdk\appconfiguration\Azure.ResourceManager.AppConfiguration\src\Generated\PrivateEndpointConnectionsRestOperations.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4// <auto-generated/>
 5
 6#nullable disable
 7
 8using System;
 9using System.Text.Json;
 10using System.Threading;
 11using System.Threading.Tasks;
 12using Azure;
 13using Azure.Core;
 14using Azure.Core.Pipeline;
 15using Azure.ResourceManager.AppConfiguration.Models;
 16
 17namespace Azure.ResourceManager.AppConfiguration
 18{
 19    internal partial class PrivateEndpointConnectionsRestOperations
 20    {
 21        private string subscriptionId;
 22        private Uri endpoint;
 23        private string apiVersion;
 24        private ClientDiagnostics _clientDiagnostics;
 25        private HttpPipeline _pipeline;
 26
 27        /// <summary> Initializes a new instance of PrivateEndpointConnectionsRestOperations. </summary>
 28        /// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
 29        /// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
 30        /// <param name="subscriptionId"> The Microsoft Azure subscription ID. </param>
 31        /// <param name="endpoint"> server parameter. </param>
 32        /// <param name="apiVersion"> Api Version. </param>
 33        /// <exception cref="ArgumentNullException"> This occurs when one of the required arguments is null. </exception
 834        public PrivateEndpointConnectionsRestOperations(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, stri
 35        {
 836            if (subscriptionId == null)
 37            {
 038                throw new ArgumentNullException(nameof(subscriptionId));
 39            }
 840            endpoint ??= new Uri("https://management.azure.com");
 841            if (apiVersion == null)
 42            {
 043                throw new ArgumentNullException(nameof(apiVersion));
 44            }
 45
 846            this.subscriptionId = subscriptionId;
 847            this.endpoint = endpoint;
 848            this.apiVersion = apiVersion;
 849            _clientDiagnostics = clientDiagnostics;
 850            _pipeline = pipeline;
 851        }
 52
 53        internal HttpMessage CreateListByConfigurationStoreRequest(string resourceGroupName, string configStoreName)
 54        {
 455            var message = _pipeline.CreateMessage();
 456            var request = message.Request;
 457            request.Method = RequestMethod.Get;
 458            var uri = new RawRequestUriBuilder();
 459            uri.Reset(endpoint);
 460            uri.AppendPath("/subscriptions/", false);
 461            uri.AppendPath(subscriptionId, true);
 462            uri.AppendPath("/resourceGroups/", false);
 463            uri.AppendPath(resourceGroupName, true);
 464            uri.AppendPath("/providers/Microsoft.AppConfiguration/configurationStores/", false);
 465            uri.AppendPath(configStoreName, true);
 466            uri.AppendPath("/privateEndpointConnections", false);
 467            uri.AppendQuery("api-version", apiVersion, true);
 468            request.Uri = uri;
 469            return message;
 70        }
 71
 72        /// <summary> Lists all private endpoint connections for a configuration store. </summary>
 73        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 74        /// <param name="configStoreName"> The name of the configuration store. </param>
 75        /// <param name="cancellationToken"> The cancellation token to use. </param>
 76        public async Task<Response<PrivateEndpointConnectionListResult>> ListByConfigurationStoreAsync(string resourceGr
 77        {
 278            if (resourceGroupName == null)
 79            {
 080                throw new ArgumentNullException(nameof(resourceGroupName));
 81            }
 282            if (configStoreName == null)
 83            {
 084                throw new ArgumentNullException(nameof(configStoreName));
 85            }
 86
 287            using var message = CreateListByConfigurationStoreRequest(resourceGroupName, configStoreName);
 288            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 289            switch (message.Response.Status)
 90            {
 91                case 200:
 92                    {
 293                        PrivateEndpointConnectionListResult value = default;
 294                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 295                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 96                        {
 097                            value = null;
 98                        }
 99                        else
 100                        {
 2101                            value = PrivateEndpointConnectionListResult.DeserializePrivateEndpointConnectionListResult(d
 102                        }
 2103                        return Response.FromValue(value, message.Response);
 104                    }
 105                default:
 0106                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 107            }
 2108        }
 109
 110        /// <summary> Lists all private endpoint connections for a configuration store. </summary>
 111        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 112        /// <param name="configStoreName"> The name of the configuration store. </param>
 113        /// <param name="cancellationToken"> The cancellation token to use. </param>
 114        public Response<PrivateEndpointConnectionListResult> ListByConfigurationStore(string resourceGroupName, string c
 115        {
 2116            if (resourceGroupName == null)
 117            {
 0118                throw new ArgumentNullException(nameof(resourceGroupName));
 119            }
 2120            if (configStoreName == null)
 121            {
 0122                throw new ArgumentNullException(nameof(configStoreName));
 123            }
 124
 2125            using var message = CreateListByConfigurationStoreRequest(resourceGroupName, configStoreName);
 2126            _pipeline.Send(message, cancellationToken);
 2127            switch (message.Response.Status)
 128            {
 129                case 200:
 130                    {
 2131                        PrivateEndpointConnectionListResult value = default;
 2132                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 2133                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 134                        {
 0135                            value = null;
 136                        }
 137                        else
 138                        {
 2139                            value = PrivateEndpointConnectionListResult.DeserializePrivateEndpointConnectionListResult(d
 140                        }
 2141                        return Response.FromValue(value, message.Response);
 142                    }
 143                default:
 0144                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 145            }
 2146        }
 147
 148        internal HttpMessage CreateGetRequest(string resourceGroupName, string configStoreName, string privateEndpointCo
 149        {
 4150            var message = _pipeline.CreateMessage();
 4151            var request = message.Request;
 4152            request.Method = RequestMethod.Get;
 4153            var uri = new RawRequestUriBuilder();
 4154            uri.Reset(endpoint);
 4155            uri.AppendPath("/subscriptions/", false);
 4156            uri.AppendPath(subscriptionId, true);
 4157            uri.AppendPath("/resourceGroups/", false);
 4158            uri.AppendPath(resourceGroupName, true);
 4159            uri.AppendPath("/providers/Microsoft.AppConfiguration/configurationStores/", false);
 4160            uri.AppendPath(configStoreName, true);
 4161            uri.AppendPath("/privateEndpointConnections/", false);
 4162            uri.AppendPath(privateEndpointConnectionName, true);
 4163            uri.AppendQuery("api-version", apiVersion, true);
 4164            request.Uri = uri;
 4165            return message;
 166        }
 167
 168        /// <summary> Gets the specified private endpoint connection associated with the configuration store. </summary>
 169        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 170        /// <param name="configStoreName"> The name of the configuration store. </param>
 171        /// <param name="privateEndpointConnectionName"> Private endpoint connection name. </param>
 172        /// <param name="cancellationToken"> The cancellation token to use. </param>
 173        public async Task<Response<PrivateEndpointConnection>> GetAsync(string resourceGroupName, string configStoreName
 174        {
 2175            if (resourceGroupName == null)
 176            {
 0177                throw new ArgumentNullException(nameof(resourceGroupName));
 178            }
 2179            if (configStoreName == null)
 180            {
 0181                throw new ArgumentNullException(nameof(configStoreName));
 182            }
 2183            if (privateEndpointConnectionName == null)
 184            {
 0185                throw new ArgumentNullException(nameof(privateEndpointConnectionName));
 186            }
 187
 2188            using var message = CreateGetRequest(resourceGroupName, configStoreName, privateEndpointConnectionName);
 2189            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 2190            switch (message.Response.Status)
 191            {
 192                case 200:
 193                    {
 2194                        PrivateEndpointConnection value = default;
 2195                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 2196                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 197                        {
 0198                            value = null;
 199                        }
 200                        else
 201                        {
 2202                            value = PrivateEndpointConnection.DeserializePrivateEndpointConnection(document.RootElement)
 203                        }
 2204                        return Response.FromValue(value, message.Response);
 205                    }
 206                default:
 0207                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 208            }
 2209        }
 210
 211        /// <summary> Gets the specified private endpoint connection associated with the configuration store. </summary>
 212        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 213        /// <param name="configStoreName"> The name of the configuration store. </param>
 214        /// <param name="privateEndpointConnectionName"> Private endpoint connection name. </param>
 215        /// <param name="cancellationToken"> The cancellation token to use. </param>
 216        public Response<PrivateEndpointConnection> Get(string resourceGroupName, string configStoreName, string privateE
 217        {
 2218            if (resourceGroupName == null)
 219            {
 0220                throw new ArgumentNullException(nameof(resourceGroupName));
 221            }
 2222            if (configStoreName == null)
 223            {
 0224                throw new ArgumentNullException(nameof(configStoreName));
 225            }
 2226            if (privateEndpointConnectionName == null)
 227            {
 0228                throw new ArgumentNullException(nameof(privateEndpointConnectionName));
 229            }
 230
 2231            using var message = CreateGetRequest(resourceGroupName, configStoreName, privateEndpointConnectionName);
 2232            _pipeline.Send(message, cancellationToken);
 2233            switch (message.Response.Status)
 234            {
 235                case 200:
 236                    {
 2237                        PrivateEndpointConnection value = default;
 2238                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 2239                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 240                        {
 0241                            value = null;
 242                        }
 243                        else
 244                        {
 2245                            value = PrivateEndpointConnection.DeserializePrivateEndpointConnection(document.RootElement)
 246                        }
 2247                        return Response.FromValue(value, message.Response);
 248                    }
 249                default:
 0250                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 251            }
 2252        }
 253
 254        internal HttpMessage CreateCreateOrUpdateRequest(string resourceGroupName, string configStoreName, string privat
 255        {
 8256            var message = _pipeline.CreateMessage();
 8257            var request = message.Request;
 8258            request.Method = RequestMethod.Put;
 8259            var uri = new RawRequestUriBuilder();
 8260            uri.Reset(endpoint);
 8261            uri.AppendPath("/subscriptions/", false);
 8262            uri.AppendPath(subscriptionId, true);
 8263            uri.AppendPath("/resourceGroups/", false);
 8264            uri.AppendPath(resourceGroupName, true);
 8265            uri.AppendPath("/providers/Microsoft.AppConfiguration/configurationStores/", false);
 8266            uri.AppendPath(configStoreName, true);
 8267            uri.AppendPath("/privateEndpointConnections/", false);
 8268            uri.AppendPath(privateEndpointConnectionName, true);
 8269            uri.AppendQuery("api-version", apiVersion, true);
 8270            request.Uri = uri;
 8271            request.Headers.Add("Content-Type", "application/json");
 8272            var content = new Utf8JsonRequestContent();
 8273            content.JsonWriter.WriteObjectValue(privateEndpointConnection);
 8274            request.Content = content;
 8275            return message;
 276        }
 277
 278        /// <summary> Update the state of the specified private endpoint connection associated with the configuration st
 279        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 280        /// <param name="configStoreName"> The name of the configuration store. </param>
 281        /// <param name="privateEndpointConnectionName"> Private endpoint connection name. </param>
 282        /// <param name="privateEndpointConnection"> The private endpoint connection properties. </param>
 283        /// <param name="cancellationToken"> The cancellation token to use. </param>
 284        public async Task<Response> CreateOrUpdateAsync(string resourceGroupName, string configStoreName, string private
 285        {
 2286            if (resourceGroupName == null)
 287            {
 0288                throw new ArgumentNullException(nameof(resourceGroupName));
 289            }
 2290            if (configStoreName == null)
 291            {
 0292                throw new ArgumentNullException(nameof(configStoreName));
 293            }
 2294            if (privateEndpointConnectionName == null)
 295            {
 0296                throw new ArgumentNullException(nameof(privateEndpointConnectionName));
 297            }
 2298            if (privateEndpointConnection == null)
 299            {
 0300                throw new ArgumentNullException(nameof(privateEndpointConnection));
 301            }
 302
 2303            using var message = CreateCreateOrUpdateRequest(resourceGroupName, configStoreName, privateEndpointConnectio
 2304            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 2305            switch (message.Response.Status)
 306            {
 307                case 200:
 308                case 201:
 2309                    return message.Response;
 310                default:
 0311                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 312            }
 2313        }
 314
 315        /// <summary> Update the state of the specified private endpoint connection associated with the configuration st
 316        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 317        /// <param name="configStoreName"> The name of the configuration store. </param>
 318        /// <param name="privateEndpointConnectionName"> Private endpoint connection name. </param>
 319        /// <param name="privateEndpointConnection"> The private endpoint connection properties. </param>
 320        /// <param name="cancellationToken"> The cancellation token to use. </param>
 321        public Response CreateOrUpdate(string resourceGroupName, string configStoreName, string privateEndpointConnectio
 322        {
 2323            if (resourceGroupName == null)
 324            {
 0325                throw new ArgumentNullException(nameof(resourceGroupName));
 326            }
 2327            if (configStoreName == null)
 328            {
 0329                throw new ArgumentNullException(nameof(configStoreName));
 330            }
 2331            if (privateEndpointConnectionName == null)
 332            {
 0333                throw new ArgumentNullException(nameof(privateEndpointConnectionName));
 334            }
 2335            if (privateEndpointConnection == null)
 336            {
 0337                throw new ArgumentNullException(nameof(privateEndpointConnection));
 338            }
 339
 2340            using var message = CreateCreateOrUpdateRequest(resourceGroupName, configStoreName, privateEndpointConnectio
 2341            _pipeline.Send(message, cancellationToken);
 2342            switch (message.Response.Status)
 343            {
 344                case 200:
 345                case 201:
 2346                    return message.Response;
 347                default:
 0348                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 349            }
 2350        }
 351
 352        internal HttpMessage CreateDeleteRequest(string resourceGroupName, string configStoreName, string privateEndpoin
 353        {
 8354            var message = _pipeline.CreateMessage();
 8355            var request = message.Request;
 8356            request.Method = RequestMethod.Delete;
 8357            var uri = new RawRequestUriBuilder();
 8358            uri.Reset(endpoint);
 8359            uri.AppendPath("/subscriptions/", false);
 8360            uri.AppendPath(subscriptionId, true);
 8361            uri.AppendPath("/resourceGroups/", false);
 8362            uri.AppendPath(resourceGroupName, true);
 8363            uri.AppendPath("/providers/Microsoft.AppConfiguration/configurationStores/", false);
 8364            uri.AppendPath(configStoreName, true);
 8365            uri.AppendPath("/privateEndpointConnections/", false);
 8366            uri.AppendPath(privateEndpointConnectionName, true);
 8367            uri.AppendQuery("api-version", apiVersion, true);
 8368            request.Uri = uri;
 8369            return message;
 370        }
 371
 372        /// <summary> Deletes a private endpoint connection. </summary>
 373        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 374        /// <param name="configStoreName"> The name of the configuration store. </param>
 375        /// <param name="privateEndpointConnectionName"> Private endpoint connection name. </param>
 376        /// <param name="cancellationToken"> The cancellation token to use. </param>
 377        public async Task<Response> DeleteAsync(string resourceGroupName, string configStoreName, string privateEndpoint
 378        {
 2379            if (resourceGroupName == null)
 380            {
 0381                throw new ArgumentNullException(nameof(resourceGroupName));
 382            }
 2383            if (configStoreName == null)
 384            {
 0385                throw new ArgumentNullException(nameof(configStoreName));
 386            }
 2387            if (privateEndpointConnectionName == null)
 388            {
 0389                throw new ArgumentNullException(nameof(privateEndpointConnectionName));
 390            }
 391
 2392            using var message = CreateDeleteRequest(resourceGroupName, configStoreName, privateEndpointConnectionName);
 2393            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 2394            switch (message.Response.Status)
 395            {
 396                case 200:
 397                case 202:
 398                case 204:
 2399                    return message.Response;
 400                default:
 0401                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 402            }
 2403        }
 404
 405        /// <summary> Deletes a private endpoint connection. </summary>
 406        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 407        /// <param name="configStoreName"> The name of the configuration store. </param>
 408        /// <param name="privateEndpointConnectionName"> Private endpoint connection name. </param>
 409        /// <param name="cancellationToken"> The cancellation token to use. </param>
 410        public Response Delete(string resourceGroupName, string configStoreName, string privateEndpointConnectionName, C
 411        {
 2412            if (resourceGroupName == null)
 413            {
 0414                throw new ArgumentNullException(nameof(resourceGroupName));
 415            }
 2416            if (configStoreName == null)
 417            {
 0418                throw new ArgumentNullException(nameof(configStoreName));
 419            }
 2420            if (privateEndpointConnectionName == null)
 421            {
 0422                throw new ArgumentNullException(nameof(privateEndpointConnectionName));
 423            }
 424
 2425            using var message = CreateDeleteRequest(resourceGroupName, configStoreName, privateEndpointConnectionName);
 2426            _pipeline.Send(message, cancellationToken);
 2427            switch (message.Response.Status)
 428            {
 429                case 200:
 430                case 202:
 431                case 204:
 2432                    return message.Response;
 433                default:
 0434                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 435            }
 2436        }
 437
 438        internal HttpMessage CreateListByConfigurationStoreNextPageRequest(string nextLink, string resourceGroupName, st
 439        {
 0440            var message = _pipeline.CreateMessage();
 0441            var request = message.Request;
 0442            request.Method = RequestMethod.Get;
 0443            var uri = new RawRequestUriBuilder();
 0444            uri.Reset(endpoint);
 0445            uri.AppendRawNextLink(nextLink, false);
 0446            request.Uri = uri;
 0447            return message;
 448        }
 449
 450        /// <summary> Lists all private endpoint connections for a configuration store. </summary>
 451        /// <param name="nextLink"> The URL to the next page of results. </param>
 452        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 453        /// <param name="configStoreName"> The name of the configuration store. </param>
 454        /// <param name="cancellationToken"> The cancellation token to use. </param>
 455        public async Task<Response<PrivateEndpointConnectionListResult>> ListByConfigurationStoreNextPageAsync(string ne
 456        {
 0457            if (nextLink == null)
 458            {
 0459                throw new ArgumentNullException(nameof(nextLink));
 460            }
 0461            if (resourceGroupName == null)
 462            {
 0463                throw new ArgumentNullException(nameof(resourceGroupName));
 464            }
 0465            if (configStoreName == null)
 466            {
 0467                throw new ArgumentNullException(nameof(configStoreName));
 468            }
 469
 0470            using var message = CreateListByConfigurationStoreNextPageRequest(nextLink, resourceGroupName, configStoreNa
 0471            await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
 0472            switch (message.Response.Status)
 473            {
 474                case 200:
 475                    {
 0476                        PrivateEndpointConnectionListResult value = default;
 0477                        using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
 0478                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 479                        {
 0480                            value = null;
 481                        }
 482                        else
 483                        {
 0484                            value = PrivateEndpointConnectionListResult.DeserializePrivateEndpointConnectionListResult(d
 485                        }
 0486                        return Response.FromValue(value, message.Response);
 487                    }
 488                default:
 0489                    throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
 490            }
 0491        }
 492
 493        /// <summary> Lists all private endpoint connections for a configuration store. </summary>
 494        /// <param name="nextLink"> The URL to the next page of results. </param>
 495        /// <param name="resourceGroupName"> The name of the resource group to which the container registry belongs. </p
 496        /// <param name="configStoreName"> The name of the configuration store. </param>
 497        /// <param name="cancellationToken"> The cancellation token to use. </param>
 498        public Response<PrivateEndpointConnectionListResult> ListByConfigurationStoreNextPage(string nextLink, string re
 499        {
 0500            if (nextLink == null)
 501            {
 0502                throw new ArgumentNullException(nameof(nextLink));
 503            }
 0504            if (resourceGroupName == null)
 505            {
 0506                throw new ArgumentNullException(nameof(resourceGroupName));
 507            }
 0508            if (configStoreName == null)
 509            {
 0510                throw new ArgumentNullException(nameof(configStoreName));
 511            }
 512
 0513            using var message = CreateListByConfigurationStoreNextPageRequest(nextLink, resourceGroupName, configStoreNa
 0514            _pipeline.Send(message, cancellationToken);
 0515            switch (message.Response.Status)
 516            {
 517                case 200:
 518                    {
 0519                        PrivateEndpointConnectionListResult value = default;
 0520                        using var document = JsonDocument.Parse(message.Response.ContentStream);
 0521                        if (document.RootElement.ValueKind == JsonValueKind.Null)
 522                        {
 0523                            value = null;
 524                        }
 525                        else
 526                        {
 0527                            value = PrivateEndpointConnectionListResult.DeserializePrivateEndpointConnectionListResult(d
 528                        }
 0529                        return Response.FromValue(value, message.Response);
 530                    }
 531                default:
 0532                    throw _clientDiagnostics.CreateRequestFailedException(message.Response);
 533            }
 0534        }
 535    }
 536}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:43 PM
GitHub | www.palmmedia.de

Methods/Properties

.ctor(...)
CreateListByConfigurationStoreRequest(...)
ListByConfigurationStoreAsync()
ListByConfigurationStore(...)
CreateGetRequest(...)
GetAsync()
Get(...)
CreateCreateOrUpdateRequest(...)
CreateOrUpdateAsync()
CreateOrUpdate(...)
CreateDeleteRequest(...)
DeleteAsync()
Delete(...)
CreateListByConfigurationStoreNextPageRequest(...)
ListByConfigurationStoreNextPageAsync()
ListByConfigurationStoreNextPage(...)