< Summary

Class:	Azure.ResourceManager.Compute.SnapshotsRestOperations
Assembly:	Azure.ResourceManager.Compute
File(s):	C:\Git\azure-sdk-for-net\sdk\compute\Azure.ResourceManager.Compute\src\Generated\SnapshotsRestOperations.cs
Covered lines:	268
Uncovered lines:	125
Coverable lines:	393
Total lines:	864
Line coverage:	68.1% (268 of 393)
Covered branches:	78
Total branches:	164
Branch coverage:	47.5% (78 of 164)

Metrics

Method	Cyclomatic complexity	Line coverage	Branch coverage
.ctor(...)	-	88.89%	50%
CreateCreateOrUpdateRequest(...)	-	100%	100%
CreateOrUpdateAsync()	-	66.67%	60%
CreateOrUpdate(...)	-	66.67%	60%
CreateUpdateRequest(...)	-	100%	100%
UpdateAsync()	-	66.67%	60%
Update(...)	-	66.67%	60%
CreateGetRequest(...)	-	100%	100%
GetAsync()	-	80%	62.5%
Get(...)	-	80%	62.5%
CreateDeleteRequest(...)	-	100%	100%
DeleteAsync()	-	70%	50%
Delete(...)	-	70%	50%
CreateListByResourceGroupRequest(...)	-	100%	100%
ListByResourceGroupAsync()	-	76.92%	50%
ListByResourceGroup(...)	-	76.92%	50%
CreateListRequest()	-	100%	100%
ListAsync()	-	81.82%	50%
List(...)	-	81.82%	50%
CreateGrantAccessRequest(...)	-	100%	100%
GrantAccessAsync()	-	66.67%	60%
GrantAccess(...)	-	66.67%	60%
CreateRevokeAccessRequest(...)	-	100%	100%
RevokeAccessAsync()	-	70%	62.5%
RevokeAccess(...)	-	70%	62.5%
CreateListByResourceGroupNextPageRequest(...)	-	0%	100%
ListByResourceGroupNextPageAsync()	-	0%	0%
ListByResourceGroupNextPage(...)	-	0%	0%
CreateListNextPageRequest(...)	-	0%	100%
ListNextPageAsync()	-	0%	0%
ListNextPage(...)	-	0%	0%

File(s)

C:\Git\azure-sdk-for-net\sdk\compute\Azure.ResourceManager.Compute\src\Generated\SnapshotsRestOperations.cs

	#	Line		Line coverage
		1		// Copyright (c) Microsoft Corporation. All rights reserved.
		2		// Licensed under the MIT License.
		3
		4		// <auto-generated/>
		5
		6		#nullable disable
		7
		8		using System;
		9		using System.Text.Json;
		10		using System.Threading;
		11		using System.Threading.Tasks;
		12		using Azure;
		13		using Azure.Core;
		14		using Azure.Core.Pipeline;
		15		using Azure.ResourceManager.Compute.Models;
		16
		17		namespace Azure.ResourceManager.Compute
		18		{
		19		internal partial class SnapshotsRestOperations
		20		{
		21		private string subscriptionId;
		22		private Uri endpoint;
		23		private ClientDiagnostics _clientDiagnostics;
		24		private HttpPipeline _pipeline;
		25
		26		/// <summary> Initializes a new instance of SnapshotsRestOperations. </summary>
		27		/// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
		28		/// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
		29		/// <param name="subscriptionId"> Subscription credentials which uniquely identify Microsoft Azure subscription.
		30		/// <param name="endpoint"> server parameter. </param>
		31		/// <exception cref="ArgumentNullException"> This occurs when one of the required arguments is null. </exception
	396	32		public SnapshotsRestOperations(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, string subscriptionId
		33		{
	396	34		if (subscriptionId == null)
		35		{
	0	36		throw new ArgumentNullException(nameof(subscriptionId));
		37		}
	396	38		endpoint ??= new Uri("https://management.azure.com");
		39
	396	40		this.subscriptionId = subscriptionId;
	396	41		this.endpoint = endpoint;
	396	42		_clientDiagnostics = clientDiagnostics;
	396	43		_pipeline = pipeline;
	396	44		}
		45
		46		internal HttpMessage CreateCreateOrUpdateRequest(string resourceGroupName, string snapshotName, Snapshot snapsho
		47		{
	48	48		var message = _pipeline.CreateMessage();
	48	49		var request = message.Request;
	48	50		request.Method = RequestMethod.Put;
	48	51		var uri = new RawRequestUriBuilder();
	48	52		uri.Reset(endpoint);
	48	53		uri.AppendPath("/subscriptions/", false);
	48	54		uri.AppendPath(subscriptionId, true);
	48	55		uri.AppendPath("/resourceGroups/", false);
	48	56		uri.AppendPath(resourceGroupName, true);
	48	57		uri.AppendPath("/providers/Microsoft.Compute/snapshots/", false);
	48	58		uri.AppendPath(snapshotName, true);
	48	59		uri.AppendQuery("api-version", "2019-11-01", true);
	48	60		request.Uri = uri;
	48	61		request.Headers.Add("Content-Type", "application/json");
	48	62		var content = new Utf8JsonRequestContent();
	48	63		content.JsonWriter.WriteObjectValue(snapshot);
	48	64		request.Content = content;
	48	65		return message;
		66		}
		67
		68		/// <summary> Creates or updates a snapshot. </summary>
		69		/// <param name="resourceGroupName"> The name of the resource group. </param>
		70		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		71		/// <param name="snapshot"> Snapshot object supplied in the body of the Put disk operation. </param>
		72		/// <param name="cancellationToken"> The cancellation token to use. </param>
		73		public async Task<Response> CreateOrUpdateAsync(string resourceGroupName, string snapshotName, Snapshot snapshot
		74		{
	12	75		if (resourceGroupName == null)
		76		{
	0	77		throw new ArgumentNullException(nameof(resourceGroupName));
		78		}
	12	79		if (snapshotName == null)
		80		{
	0	81		throw new ArgumentNullException(nameof(snapshotName));
		82		}
	12	83		if (snapshot == null)
		84		{
	0	85		throw new ArgumentNullException(nameof(snapshot));
		86		}
		87
	12	88		using var message = CreateCreateOrUpdateRequest(resourceGroupName, snapshotName, snapshot);
	12	89		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	12	90		switch (message.Response.Status)
		91		{
		92		case 200:
		93		case 202:
	12	94		return message.Response;
		95		default:
	0	96		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		97		}
	12	98		}
		99
		100		/// <summary> Creates or updates a snapshot. </summary>
		101		/// <param name="resourceGroupName"> The name of the resource group. </param>
		102		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		103		/// <param name="snapshot"> Snapshot object supplied in the body of the Put disk operation. </param>
		104		/// <param name="cancellationToken"> The cancellation token to use. </param>
		105		public Response CreateOrUpdate(string resourceGroupName, string snapshotName, Snapshot snapshot, CancellationTok
		106		{
	12	107		if (resourceGroupName == null)
		108		{
	0	109		throw new ArgumentNullException(nameof(resourceGroupName));
		110		}
	12	111		if (snapshotName == null)
		112		{
	0	113		throw new ArgumentNullException(nameof(snapshotName));
		114		}
	12	115		if (snapshot == null)
		116		{
	0	117		throw new ArgumentNullException(nameof(snapshot));
		118		}
		119
	12	120		using var message = CreateCreateOrUpdateRequest(resourceGroupName, snapshotName, snapshot);
	12	121		_pipeline.Send(message, cancellationToken);
	12	122		switch (message.Response.Status)
		123		{
		124		case 200:
		125		case 202:
	12	126		return message.Response;
		127		default:
	0	128		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		129		}
	12	130		}
		131
		132		internal HttpMessage CreateUpdateRequest(string resourceGroupName, string snapshotName, SnapshotUpdate snapshot)
		133		{
	16	134		var message = _pipeline.CreateMessage();
	16	135		var request = message.Request;
	16	136		request.Method = RequestMethod.Patch;
	16	137		var uri = new RawRequestUriBuilder();
	16	138		uri.Reset(endpoint);
	16	139		uri.AppendPath("/subscriptions/", false);
	16	140		uri.AppendPath(subscriptionId, true);
	16	141		uri.AppendPath("/resourceGroups/", false);
	16	142		uri.AppendPath(resourceGroupName, true);
	16	143		uri.AppendPath("/providers/Microsoft.Compute/snapshots/", false);
	16	144		uri.AppendPath(snapshotName, true);
	16	145		uri.AppendQuery("api-version", "2019-11-01", true);
	16	146		request.Uri = uri;
	16	147		request.Headers.Add("Content-Type", "application/json");
	16	148		var content = new Utf8JsonRequestContent();
	16	149		content.JsonWriter.WriteObjectValue(snapshot);
	16	150		request.Content = content;
	16	151		return message;
		152		}
		153
		154		/// <summary> Updates (patches) a snapshot. </summary>
		155		/// <param name="resourceGroupName"> The name of the resource group. </param>
		156		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		157		/// <param name="snapshot"> Snapshot object supplied in the body of the Patch snapshot operation. </param>
		158		/// <param name="cancellationToken"> The cancellation token to use. </param>
		159		public async Task<Response> UpdateAsync(string resourceGroupName, string snapshotName, SnapshotUpdate snapshot,
		160		{
	4	161		if (resourceGroupName == null)
		162		{
	0	163		throw new ArgumentNullException(nameof(resourceGroupName));
		164		}
	4	165		if (snapshotName == null)
		166		{
	0	167		throw new ArgumentNullException(nameof(snapshotName));
		168		}
	4	169		if (snapshot == null)
		170		{
	0	171		throw new ArgumentNullException(nameof(snapshot));
		172		}
		173
	4	174		using var message = CreateUpdateRequest(resourceGroupName, snapshotName, snapshot);
	4	175		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	4	176		switch (message.Response.Status)
		177		{
		178		case 200:
		179		case 202:
	4	180		return message.Response;
		181		default:
	0	182		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		183		}
	4	184		}
		185
		186		/// <summary> Updates (patches) a snapshot. </summary>
		187		/// <param name="resourceGroupName"> The name of the resource group. </param>
		188		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		189		/// <param name="snapshot"> Snapshot object supplied in the body of the Patch snapshot operation. </param>
		190		/// <param name="cancellationToken"> The cancellation token to use. </param>
		191		public Response Update(string resourceGroupName, string snapshotName, SnapshotUpdate snapshot, CancellationToken
		192		{
	4	193		if (resourceGroupName == null)
		194		{
	0	195		throw new ArgumentNullException(nameof(resourceGroupName));
		196		}
	4	197		if (snapshotName == null)
		198		{
	0	199		throw new ArgumentNullException(nameof(snapshotName));
		200		}
	4	201		if (snapshot == null)
		202		{
	0	203		throw new ArgumentNullException(nameof(snapshot));
		204		}
		205
	4	206		using var message = CreateUpdateRequest(resourceGroupName, snapshotName, snapshot);
	4	207		_pipeline.Send(message, cancellationToken);
	4	208		switch (message.Response.Status)
		209		{
		210		case 200:
		211		case 202:
	4	212		return message.Response;
		213		default:
	0	214		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		215		}
	4	216		}
		217
		218		internal HttpMessage CreateGetRequest(string resourceGroupName, string snapshotName)
		219		{
	32	220		var message = _pipeline.CreateMessage();
	32	221		var request = message.Request;
	32	222		request.Method = RequestMethod.Get;
	32	223		var uri = new RawRequestUriBuilder();
	32	224		uri.Reset(endpoint);
	32	225		uri.AppendPath("/subscriptions/", false);
	32	226		uri.AppendPath(subscriptionId, true);
	32	227		uri.AppendPath("/resourceGroups/", false);
	32	228		uri.AppendPath(resourceGroupName, true);
	32	229		uri.AppendPath("/providers/Microsoft.Compute/snapshots/", false);
	32	230		uri.AppendPath(snapshotName, true);
	32	231		uri.AppendQuery("api-version", "2019-11-01", true);
	32	232		request.Uri = uri;
	32	233		return message;
		234		}
		235
		236		/// <summary> Gets information about a snapshot. </summary>
		237		/// <param name="resourceGroupName"> The name of the resource group. </param>
		238		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		239		/// <param name="cancellationToken"> The cancellation token to use. </param>
		240		public async Task<Response<Snapshot>> GetAsync(string resourceGroupName, string snapshotName, CancellationToken
		241		{
	16	242		if (resourceGroupName == null)
		243		{
	0	244		throw new ArgumentNullException(nameof(resourceGroupName));
		245		}
	16	246		if (snapshotName == null)
		247		{
	0	248		throw new ArgumentNullException(nameof(snapshotName));
		249		}
		250
	16	251		using var message = CreateGetRequest(resourceGroupName, snapshotName);
	16	252		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	16	253		switch (message.Response.Status)
		254		{
		255		case 200:
		256		{
	12	257		Snapshot value = default;
	12	258		using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
	12	259		if (document.RootElement.ValueKind == JsonValueKind.Null)
		260		{
	0	261		value = null;
		262		}
		263		else
		264		{
	12	265		value = Snapshot.DeserializeSnapshot(document.RootElement);
		266		}
	12	267		return Response.FromValue(value, message.Response);
		268		}
		269		default:
	4	270		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		271		}
	12	272		}
		273
		274		/// <summary> Gets information about a snapshot. </summary>
		275		/// <param name="resourceGroupName"> The name of the resource group. </param>
		276		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		277		/// <param name="cancellationToken"> The cancellation token to use. </param>
		278		public Response<Snapshot> Get(string resourceGroupName, string snapshotName, CancellationToken cancellationToken
		279		{
	16	280		if (resourceGroupName == null)
		281		{
	0	282		throw new ArgumentNullException(nameof(resourceGroupName));
		283		}
	16	284		if (snapshotName == null)
		285		{
	0	286		throw new ArgumentNullException(nameof(snapshotName));
		287		}
		288
	16	289		using var message = CreateGetRequest(resourceGroupName, snapshotName);
	16	290		_pipeline.Send(message, cancellationToken);
	16	291		switch (message.Response.Status)
		292		{
		293		case 200:
		294		{
	12	295		Snapshot value = default;
	12	296		using var document = JsonDocument.Parse(message.Response.ContentStream);
	12	297		if (document.RootElement.ValueKind == JsonValueKind.Null)
		298		{
	0	299		value = null;
		300		}
		301		else
		302		{
	12	303		value = Snapshot.DeserializeSnapshot(document.RootElement);
		304		}
	12	305		return Response.FromValue(value, message.Response);
		306		}
		307		default:
	4	308		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		309		}
	12	310		}
		311
		312		internal HttpMessage CreateDeleteRequest(string resourceGroupName, string snapshotName)
		313		{
	16	314		var message = _pipeline.CreateMessage();
	16	315		var request = message.Request;
	16	316		request.Method = RequestMethod.Delete;
	16	317		var uri = new RawRequestUriBuilder();
	16	318		uri.Reset(endpoint);
	16	319		uri.AppendPath("/subscriptions/", false);
	16	320		uri.AppendPath(subscriptionId, true);
	16	321		uri.AppendPath("/resourceGroups/", false);
	16	322		uri.AppendPath(resourceGroupName, true);
	16	323		uri.AppendPath("/providers/Microsoft.Compute/snapshots/", false);
	16	324		uri.AppendPath(snapshotName, true);
	16	325		uri.AppendQuery("api-version", "2019-11-01", true);
	16	326		request.Uri = uri;
	16	327		return message;
		328		}
		329
		330		/// <summary> Deletes a snapshot. </summary>
		331		/// <param name="resourceGroupName"> The name of the resource group. </param>
		332		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		333		/// <param name="cancellationToken"> The cancellation token to use. </param>
		334		public async Task<Response> DeleteAsync(string resourceGroupName, string snapshotName, CancellationToken cancell
		335		{
	4	336		if (resourceGroupName == null)
		337		{
	0	338		throw new ArgumentNullException(nameof(resourceGroupName));
		339		}
	4	340		if (snapshotName == null)
		341		{
	0	342		throw new ArgumentNullException(nameof(snapshotName));
		343		}
		344
	4	345		using var message = CreateDeleteRequest(resourceGroupName, snapshotName);
	4	346		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	4	347		switch (message.Response.Status)
		348		{
		349		case 200:
		350		case 202:
		351		case 204:
	4	352		return message.Response;
		353		default:
	0	354		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		355		}
	4	356		}
		357
		358		/// <summary> Deletes a snapshot. </summary>
		359		/// <param name="resourceGroupName"> The name of the resource group. </param>
		360		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		361		/// <param name="cancellationToken"> The cancellation token to use. </param>
		362		public Response Delete(string resourceGroupName, string snapshotName, CancellationToken cancellationToken = defa
		363		{
	4	364		if (resourceGroupName == null)
		365		{
	0	366		throw new ArgumentNullException(nameof(resourceGroupName));
		367		}
	4	368		if (snapshotName == null)
		369		{
	0	370		throw new ArgumentNullException(nameof(snapshotName));
		371		}
		372
	4	373		using var message = CreateDeleteRequest(resourceGroupName, snapshotName);
	4	374		_pipeline.Send(message, cancellationToken);
	4	375		switch (message.Response.Status)
		376		{
		377		case 200:
		378		case 202:
		379		case 204:
	4	380		return message.Response;
		381		default:
	0	382		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		383		}
	4	384		}
		385
		386		internal HttpMessage CreateListByResourceGroupRequest(string resourceGroupName)
		387		{
	8	388		var message = _pipeline.CreateMessage();
	8	389		var request = message.Request;
	8	390		request.Method = RequestMethod.Get;
	8	391		var uri = new RawRequestUriBuilder();
	8	392		uri.Reset(endpoint);
	8	393		uri.AppendPath("/subscriptions/", false);
	8	394		uri.AppendPath(subscriptionId, true);
	8	395		uri.AppendPath("/resourceGroups/", false);
	8	396		uri.AppendPath(resourceGroupName, true);
	8	397		uri.AppendPath("/providers/Microsoft.Compute/snapshots", false);
	8	398		uri.AppendQuery("api-version", "2019-11-01", true);
	8	399		request.Uri = uri;
	8	400		return message;
		401		}
		402
		403		/// <summary> Lists snapshots under a resource group. </summary>
		404		/// <param name="resourceGroupName"> The name of the resource group. </param>
		405		/// <param name="cancellationToken"> The cancellation token to use. </param>
		406		public async Task<Response<SnapshotList>> ListByResourceGroupAsync(string resourceGroupName, CancellationToken c
		407		{
	4	408		if (resourceGroupName == null)
		409		{
	0	410		throw new ArgumentNullException(nameof(resourceGroupName));
		411		}
		412
	4	413		using var message = CreateListByResourceGroupRequest(resourceGroupName);
	4	414		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	4	415		switch (message.Response.Status)
		416		{
		417		case 200:
		418		{
	4	419		SnapshotList value = default;
	4	420		using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
	4	421		if (document.RootElement.ValueKind == JsonValueKind.Null)
		422		{
	0	423		value = null;
		424		}
		425		else
		426		{
	4	427		value = SnapshotList.DeserializeSnapshotList(document.RootElement);
		428		}
	4	429		return Response.FromValue(value, message.Response);
		430		}
		431		default:
	0	432		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		433		}
	4	434		}
		435
		436		/// <summary> Lists snapshots under a resource group. </summary>
		437		/// <param name="resourceGroupName"> The name of the resource group. </param>
		438		/// <param name="cancellationToken"> The cancellation token to use. </param>
		439		public Response<SnapshotList> ListByResourceGroup(string resourceGroupName, CancellationToken cancellationToken
		440		{
	4	441		if (resourceGroupName == null)
		442		{
	0	443		throw new ArgumentNullException(nameof(resourceGroupName));
		444		}
		445
	4	446		using var message = CreateListByResourceGroupRequest(resourceGroupName);
	4	447		_pipeline.Send(message, cancellationToken);
	4	448		switch (message.Response.Status)
		449		{
		450		case 200:
		451		{
	4	452		SnapshotList value = default;
	4	453		using var document = JsonDocument.Parse(message.Response.ContentStream);
	4	454		if (document.RootElement.ValueKind == JsonValueKind.Null)
		455		{
	0	456		value = null;
		457		}
		458		else
		459		{
	4	460		value = SnapshotList.DeserializeSnapshotList(document.RootElement);
		461		}
	4	462		return Response.FromValue(value, message.Response);
		463		}
		464		default:
	0	465		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		466		}
	4	467		}
		468
		469		internal HttpMessage CreateListRequest()
		470		{
	4	471		var message = _pipeline.CreateMessage();
	4	472		var request = message.Request;
	4	473		request.Method = RequestMethod.Get;
	4	474		var uri = new RawRequestUriBuilder();
	4	475		uri.Reset(endpoint);
	4	476		uri.AppendPath("/subscriptions/", false);
	4	477		uri.AppendPath(subscriptionId, true);
	4	478		uri.AppendPath("/providers/Microsoft.Compute/snapshots", false);
	4	479		uri.AppendQuery("api-version", "2019-11-01", true);
	4	480		request.Uri = uri;
	4	481		return message;
		482		}
		483
		484		/// <summary> Lists snapshots under a subscription. </summary>
		485		/// <param name="cancellationToken"> The cancellation token to use. </param>
		486		public async Task<Response<SnapshotList>> ListAsync(CancellationToken cancellationToken = default)
		487		{
	2	488		using var message = CreateListRequest();
	2	489		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	2	490		switch (message.Response.Status)
		491		{
		492		case 200:
		493		{
	2	494		SnapshotList value = default;
	2	495		using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
	2	496		if (document.RootElement.ValueKind == JsonValueKind.Null)
		497		{
	0	498		value = null;
		499		}
		500		else
		501		{
	2	502		value = SnapshotList.DeserializeSnapshotList(document.RootElement);
		503		}
	2	504		return Response.FromValue(value, message.Response);
		505		}
		506		default:
	0	507		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		508		}
	2	509		}
		510
		511		/// <summary> Lists snapshots under a subscription. </summary>
		512		/// <param name="cancellationToken"> The cancellation token to use. </param>
		513		public Response<SnapshotList> List(CancellationToken cancellationToken = default)
		514		{
	2	515		using var message = CreateListRequest();
	2	516		_pipeline.Send(message, cancellationToken);
	2	517		switch (message.Response.Status)
		518		{
		519		case 200:
		520		{
	2	521		SnapshotList value = default;
	2	522		using var document = JsonDocument.Parse(message.Response.ContentStream);
	2	523		if (document.RootElement.ValueKind == JsonValueKind.Null)
		524		{
	0	525		value = null;
		526		}
		527		else
		528		{
	2	529		value = SnapshotList.DeserializeSnapshotList(document.RootElement);
		530		}
	2	531		return Response.FromValue(value, message.Response);
		532		}
		533		default:
	0	534		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		535		}
	2	536		}
		537
		538		internal HttpMessage CreateGrantAccessRequest(string resourceGroupName, string snapshotName, GrantAccessData gra
		539		{
	16	540		var message = _pipeline.CreateMessage();
	16	541		var request = message.Request;
	16	542		request.Method = RequestMethod.Post;
	16	543		var uri = new RawRequestUriBuilder();
	16	544		uri.Reset(endpoint);
	16	545		uri.AppendPath("/subscriptions/", false);
	16	546		uri.AppendPath(subscriptionId, true);
	16	547		uri.AppendPath("/resourceGroups/", false);
	16	548		uri.AppendPath(resourceGroupName, true);
	16	549		uri.AppendPath("/providers/Microsoft.Compute/snapshots/", false);
	16	550		uri.AppendPath(snapshotName, true);
	16	551		uri.AppendPath("/beginGetAccess", false);
	16	552		uri.AppendQuery("api-version", "2019-11-01", true);
	16	553		request.Uri = uri;
	16	554		request.Headers.Add("Content-Type", "application/json");
	16	555		var content = new Utf8JsonRequestContent();
	16	556		content.JsonWriter.WriteObjectValue(grantAccessData);
	16	557		request.Content = content;
	16	558		return message;
		559		}
		560
		561		/// <summary> Grants access to a snapshot. </summary>
		562		/// <param name="resourceGroupName"> The name of the resource group. </param>
		563		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		564		/// <param name="grantAccessData"> Access data object supplied in the body of the get snapshot access operation.
		565		/// <param name="cancellationToken"> The cancellation token to use. </param>
		566		public async Task<Response> GrantAccessAsync(string resourceGroupName, string snapshotName, GrantAccessData gran
		567		{
	4	568		if (resourceGroupName == null)
		569		{
	0	570		throw new ArgumentNullException(nameof(resourceGroupName));
		571		}
	4	572		if (snapshotName == null)
		573		{
	0	574		throw new ArgumentNullException(nameof(snapshotName));
		575		}
	4	576		if (grantAccessData == null)
		577		{
	0	578		throw new ArgumentNullException(nameof(grantAccessData));
		579		}
		580
	4	581		using var message = CreateGrantAccessRequest(resourceGroupName, snapshotName, grantAccessData);
	4	582		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	4	583		switch (message.Response.Status)
		584		{
		585		case 200:
		586		case 202:
	4	587		return message.Response;
		588		default:
	0	589		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		590		}
	4	591		}
		592
		593		/// <summary> Grants access to a snapshot. </summary>
		594		/// <param name="resourceGroupName"> The name of the resource group. </param>
		595		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		596		/// <param name="grantAccessData"> Access data object supplied in the body of the get snapshot access operation.
		597		/// <param name="cancellationToken"> The cancellation token to use. </param>
		598		public Response GrantAccess(string resourceGroupName, string snapshotName, GrantAccessData grantAccessData, Canc
		599		{
	4	600		if (resourceGroupName == null)
		601		{
	0	602		throw new ArgumentNullException(nameof(resourceGroupName));
		603		}
	4	604		if (snapshotName == null)
		605		{
	0	606		throw new ArgumentNullException(nameof(snapshotName));
		607		}
	4	608		if (grantAccessData == null)
		609		{
	0	610		throw new ArgumentNullException(nameof(grantAccessData));
		611		}
		612
	4	613		using var message = CreateGrantAccessRequest(resourceGroupName, snapshotName, grantAccessData);
	4	614		_pipeline.Send(message, cancellationToken);
	4	615		switch (message.Response.Status)
		616		{
		617		case 200:
		618		case 202:
	4	619		return message.Response;
		620		default:
	0	621		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		622		}
	4	623		}
		624
		625		internal HttpMessage CreateRevokeAccessRequest(string resourceGroupName, string snapshotName)
		626		{
	16	627		var message = _pipeline.CreateMessage();
	16	628		var request = message.Request;
	16	629		request.Method = RequestMethod.Post;
	16	630		var uri = new RawRequestUriBuilder();
	16	631		uri.Reset(endpoint);
	16	632		uri.AppendPath("/subscriptions/", false);
	16	633		uri.AppendPath(subscriptionId, true);
	16	634		uri.AppendPath("/resourceGroups/", false);
	16	635		uri.AppendPath(resourceGroupName, true);
	16	636		uri.AppendPath("/providers/Microsoft.Compute/snapshots/", false);
	16	637		uri.AppendPath(snapshotName, true);
	16	638		uri.AppendPath("/endGetAccess", false);
	16	639		uri.AppendQuery("api-version", "2019-11-01", true);
	16	640		request.Uri = uri;
	16	641		return message;
		642		}
		643
		644		/// <summary> Revokes access to a snapshot. </summary>
		645		/// <param name="resourceGroupName"> The name of the resource group. </param>
		646		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		647		/// <param name="cancellationToken"> The cancellation token to use. </param>
		648		public async Task<Response> RevokeAccessAsync(string resourceGroupName, string snapshotName, CancellationToken c
		649		{
	4	650		if (resourceGroupName == null)
		651		{
	0	652		throw new ArgumentNullException(nameof(resourceGroupName));
		653		}
	4	654		if (snapshotName == null)
		655		{
	0	656		throw new ArgumentNullException(nameof(snapshotName));
		657		}
		658
	4	659		using var message = CreateRevokeAccessRequest(resourceGroupName, snapshotName);
	4	660		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	4	661		switch (message.Response.Status)
		662		{
		663		case 200:
		664		case 202:
	4	665		return message.Response;
		666		default:
	0	667		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		668		}
	4	669		}
		670
		671		/// <summary> Revokes access to a snapshot. </summary>
		672		/// <param name="resourceGroupName"> The name of the resource group. </param>
		673		/// <param name="snapshotName"> The name of the snapshot that is being created. The name can&apos;t be changed a
		674		/// <param name="cancellationToken"> The cancellation token to use. </param>
		675		public Response RevokeAccess(string resourceGroupName, string snapshotName, CancellationToken cancellationToken
		676		{
	4	677		if (resourceGroupName == null)
		678		{
	0	679		throw new ArgumentNullException(nameof(resourceGroupName));
		680		}
	4	681		if (snapshotName == null)
		682		{
	0	683		throw new ArgumentNullException(nameof(snapshotName));
		684		}
		685
	4	686		using var message = CreateRevokeAccessRequest(resourceGroupName, snapshotName);
	4	687		_pipeline.Send(message, cancellationToken);
	4	688		switch (message.Response.Status)
		689		{
		690		case 200:
		691		case 202:
	4	692		return message.Response;
		693		default:
	0	694		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		695		}
	4	696		}
		697
		698		internal HttpMessage CreateListByResourceGroupNextPageRequest(string nextLink, string resourceGroupName)
		699		{
	0	700		var message = _pipeline.CreateMessage();
	0	701		var request = message.Request;
	0	702		request.Method = RequestMethod.Get;
	0	703		var uri = new RawRequestUriBuilder();
	0	704		uri.Reset(endpoint);
	0	705		uri.AppendRawNextLink(nextLink, false);
	0	706		request.Uri = uri;
	0	707		return message;
		708		}
		709
		710		/// <summary> Lists snapshots under a resource group. </summary>
		711		/// <param name="nextLink"> The URL to the next page of results. </param>
		712		/// <param name="resourceGroupName"> The name of the resource group. </param>
		713		/// <param name="cancellationToken"> The cancellation token to use. </param>
		714		public async Task<Response<SnapshotList>> ListByResourceGroupNextPageAsync(string nextLink, string resourceGroup
		715		{
	0	716		if (nextLink == null)
		717		{
	0	718		throw new ArgumentNullException(nameof(nextLink));
		719		}
	0	720		if (resourceGroupName == null)
		721		{
	0	722		throw new ArgumentNullException(nameof(resourceGroupName));
		723		}
		724
	0	725		using var message = CreateListByResourceGroupNextPageRequest(nextLink, resourceGroupName);
	0	726		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	0	727		switch (message.Response.Status)
		728		{
		729		case 200:
		730		{
	0	731		SnapshotList value = default;
	0	732		using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
	0	733		if (document.RootElement.ValueKind == JsonValueKind.Null)
		734		{
	0	735		value = null;
		736		}
		737		else
		738		{
	0	739		value = SnapshotList.DeserializeSnapshotList(document.RootElement);
		740		}
	0	741		return Response.FromValue(value, message.Response);
		742		}
		743		default:
	0	744		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		745		}
	0	746		}
		747
		748		/// <summary> Lists snapshots under a resource group. </summary>
		749		/// <param name="nextLink"> The URL to the next page of results. </param>
		750		/// <param name="resourceGroupName"> The name of the resource group. </param>
		751		/// <param name="cancellationToken"> The cancellation token to use. </param>
		752		public Response<SnapshotList> ListByResourceGroupNextPage(string nextLink, string resourceGroupName, Cancellatio
		753		{
	0	754		if (nextLink == null)
		755		{
	0	756		throw new ArgumentNullException(nameof(nextLink));
		757		}
	0	758		if (resourceGroupName == null)
		759		{
	0	760		throw new ArgumentNullException(nameof(resourceGroupName));
		761		}
		762
	0	763		using var message = CreateListByResourceGroupNextPageRequest(nextLink, resourceGroupName);
	0	764		_pipeline.Send(message, cancellationToken);
	0	765		switch (message.Response.Status)
		766		{
		767		case 200:
		768		{
	0	769		SnapshotList value = default;
	0	770		using var document = JsonDocument.Parse(message.Response.ContentStream);
	0	771		if (document.RootElement.ValueKind == JsonValueKind.Null)
		772		{
	0	773		value = null;
		774		}
		775		else
		776		{
	0	777		value = SnapshotList.DeserializeSnapshotList(document.RootElement);
		778		}
	0	779		return Response.FromValue(value, message.Response);
		780		}
		781		default:
	0	782		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		783		}
	0	784		}
		785
		786		internal HttpMessage CreateListNextPageRequest(string nextLink)
		787		{
	0	788		var message = _pipeline.CreateMessage();
	0	789		var request = message.Request;
	0	790		request.Method = RequestMethod.Get;
	0	791		var uri = new RawRequestUriBuilder();
	0	792		uri.Reset(endpoint);
	0	793		uri.AppendRawNextLink(nextLink, false);
	0	794		request.Uri = uri;
	0	795		return message;
		796		}
		797
		798		/// <summary> Lists snapshots under a subscription. </summary>
		799		/// <param name="nextLink"> The URL to the next page of results. </param>
		800		/// <param name="cancellationToken"> The cancellation token to use. </param>
		801		public async Task<Response<SnapshotList>> ListNextPageAsync(string nextLink, CancellationToken cancellationToken
		802		{
	0	803		if (nextLink == null)
		804		{
	0	805		throw new ArgumentNullException(nameof(nextLink));
		806		}
		807
	0	808		using var message = CreateListNextPageRequest(nextLink);
	0	809		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	0	810		switch (message.Response.Status)
		811		{
		812		case 200:
		813		{
	0	814		SnapshotList value = default;
	0	815		using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
	0	816		if (document.RootElement.ValueKind == JsonValueKind.Null)
		817		{
	0	818		value = null;
		819		}
		820		else
		821		{
	0	822		value = SnapshotList.DeserializeSnapshotList(document.RootElement);
		823		}
	0	824		return Response.FromValue(value, message.Response);
		825		}
		826		default:
	0	827		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		828		}
	0	829		}
		830
		831		/// <summary> Lists snapshots under a subscription. </summary>
		832		/// <param name="nextLink"> The URL to the next page of results. </param>
		833		/// <param name="cancellationToken"> The cancellation token to use. </param>
		834		public Response<SnapshotList> ListNextPage(string nextLink, CancellationToken cancellationToken = default)
		835		{
	0	836		if (nextLink == null)
		837		{
	0	838		throw new ArgumentNullException(nameof(nextLink));
		839		}
		840
	0	841		using var message = CreateListNextPageRequest(nextLink);
	0	842		_pipeline.Send(message, cancellationToken);
	0	843		switch (message.Response.Status)
		844		{
		845		case 200:
		846		{
	0	847		SnapshotList value = default;
	0	848		using var document = JsonDocument.Parse(message.Response.ContentStream);
	0	849		if (document.RootElement.ValueKind == JsonValueKind.Null)
		850		{
	0	851		value = null;
		852		}
		853		else
		854		{
	0	855		value = SnapshotList.DeserializeSnapshotList(document.RootElement);
		856		}
	0	857		return Response.FromValue(value, message.Response);
		858		}
		859		default:
	0	860		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		861		}
	0	862		}
		863		}
		864		}