< Summary

Class:	Azure.ResourceManager.Resources.DeploymentsOperations
Assembly:	Azure.ResourceManager.Resources
File(s):	C:\Git\azure-sdk-for-net\sdk\resources\Azure.ResourceManager.Resources\src\Generated\DeploymentsOperations.cs
Covered lines:	222
Uncovered lines:	690
Coverable lines:	912
Total lines:	2282
Line coverage:	24.3% (222 of 912)
Covered branches:	56
Total branches:	168
Branch coverage:	33.3% (56 of 168)

Metrics

Method	Cyclomatic complexity	Line coverage	Branch coverage
get_RestClient()	-	100%	100%
.ctor()	-	100%	100%
.ctor(...)	-	100%	100%
CheckExistenceAtScopeAsync()	-	0%	100%
CheckExistenceAtScope(...)	-	0%	100%
GetAtScopeAsync()	-	57.14%	100%
GetAtScope(...)	-	57.14%	100%
CancelAtScopeAsync()	-	0%	100%
CancelAtScope(...)	-	0%	100%
ExportTemplateAtScopeAsync()	-	0%	100%
ExportTemplateAtScope(...)	-	0%	100%
CheckExistenceAtTenantScopeAsync()	-	0%	100%
CheckExistenceAtTenantScope(...)	-	0%	100%
GetAtTenantScopeAsync()	-	0%	100%
GetAtTenantScope(...)	-	0%	100%
CancelAtTenantScopeAsync()	-	0%	100%
CancelAtTenantScope(...)	-	0%	100%
ExportTemplateAtTenantScopeAsync()	-	0%	100%
ExportTemplateAtTenantScope(...)	-	0%	100%
CheckExistenceAtManagementGroupScopeAsync()	-	0%	100%
CheckExistenceAtManagementGroupScope(...)	-	0%	100%
GetAtManagementGroupScopeAsync()	-	57.14%	100%
GetAtManagementGroupScope(...)	-	57.14%	100%
CancelAtManagementGroupScopeAsync()	-	0%	100%
CancelAtManagementGroupScope(...)	-	0%	100%
ExportTemplateAtManagementGroupScopeAsync()	-	0%	100%
ExportTemplateAtManagementGroupScope(...)	-	0%	100%
CheckExistenceAtSubscriptionScopeAsync()	-	0%	100%
CheckExistenceAtSubscriptionScope(...)	-	0%	100%
GetAtSubscriptionScopeAsync()	-	57.14%	100%
GetAtSubscriptionScope(...)	-	57.14%	100%
CancelAtSubscriptionScopeAsync()	-	0%	100%
CancelAtSubscriptionScope(...)	-	0%	100%
ExportTemplateAtSubscriptionScopeAsync()	-	0%	100%
ExportTemplateAtSubscriptionScope(...)	-	0%	100%
CheckExistenceAsync()	-	0%	100%
CheckExistence(...)	-	0%	100%
GetAsync()	-	57.14%	100%
Get(...)	-	57.14%	100%
CancelAsync()	-	100%	100%
Cancel(...)	-	100%	100%
ExportTemplateAsync()	-	0%	100%
ExportTemplate(...)	-	0%	100%
CalculateTemplateHashAsync()	-	0%	100%
CalculateTemplateHash(...)	-	0%	100%
ListAtScopeAsync(...)	-	0%	0%
<ListAtScopeAsync()	-	0%	100%
<ListAtScopeAsync()	-	0%	100%
ListAtScope(...)	-	0%	0%
<ListAtTenantScopeAsync()	-	0%	100%
<ListAtTenantScopeAsync()	-	0%	100%
ListAtTenantScopeAsync(...)	-	0%	100%
ListAtTenantScope(...)	-	0%	100%
ListAtManagementGroupScopeAsync(...)	-	0%	0%
<ListAtManagementGroupScopeAsync()	-	0%	100%
<ListAtManagementGroupScopeAsync()	-	0%	100%
ListAtManagementGroupScope(...)	-	0%	0%
<ListAtSubscriptionScopeAsync()	-	0%	100%
<ListAtSubscriptionScopeAsync()	-	0%	100%
ListAtSubscriptionScopeAsync(...)	-	0%	100%
ListAtSubscriptionScope(...)	-	0%	100%
ListByResourceGroupAsync(...)	-	36.84%	50%
<ListByResourceGroupAsync()	-	62.5%	100%
<ListByResourceGroupAsync()	-	0%	100%
ListByResourceGroup(...)	-	36.84%	50%
StartDeleteAtScopeAsync()	-	0%	0%
StartDeleteAtScope(...)	-	0%	0%
StartCreateOrUpdateAtScopeAsync()	-	57.14%	50%
StartCreateOrUpdateAtScope(...)	-	57.14%	50%
StartValidateAtScopeAsync()	-	57.14%	50%
StartValidateAtScope(...)	-	57.14%	50%
StartDeleteAtTenantScopeAsync()	-	0%	0%
StartDeleteAtTenantScope(...)	-	0%	0%
StartCreateOrUpdateAtTenantScopeAsync()	-	0%	0%
StartCreateOrUpdateAtTenantScope(...)	-	0%	0%
StartValidateAtTenantScopeAsync()	-	0%	0%
StartValidateAtTenantScope(...)	-	0%	0%
StartDeleteAtManagementGroupScopeAsync()	-	0%	0%
StartDeleteAtManagementGroupScope(...)	-	0%	0%
StartCreateOrUpdateAtManagementGroupScopeAsync()	-	57.14%	50%
StartCreateOrUpdateAtManagementGroupScope(...)	-	57.14%	50%
StartValidateAtManagementGroupScopeAsync()	-	57.14%	50%
StartValidateAtManagementGroupScope(...)	-	57.14%	50%
StartDeleteAtSubscriptionScopeAsync()	-	0%	0%
StartDeleteAtSubscriptionScope(...)	-	0%	0%
StartCreateOrUpdateAtSubscriptionScopeAsync()	-	58.33%	50%
StartCreateOrUpdateAtSubscriptionScope(...)	-	58.33%	50%
StartValidateAtSubscriptionScopeAsync()	-	58.33%	50%
StartValidateAtSubscriptionScope(...)	-	58.33%	50%
StartWhatIfAtSubscriptionScopeAsync()	-	58.33%	50%
StartWhatIfAtSubscriptionScope(...)	-	58.33%	50%
StartDeleteAsync()	-	0%	0%
StartDelete(...)	-	0%	0%
StartCreateOrUpdateAsync()	-	57.14%	50%
StartCreateOrUpdate(...)	-	57.14%	50%
StartValidateAsync()	-	57.14%	50%
StartValidate(...)	-	57.14%	50%
StartWhatIfAsync()	-	57.14%	50%
StartWhatIf(...)	-	57.14%	50%

File(s)

C:\Git\azure-sdk-for-net\sdk\resources\Azure.ResourceManager.Resources\src\Generated\DeploymentsOperations.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.Threading;
		10		using System.Threading.Tasks;
		11		using Azure;
		12		using Azure.Core;
		13		using Azure.Core.Pipeline;
		14		using Azure.ResourceManager.Resources.Models;
		15
		16		namespace Azure.ResourceManager.Resources
		17		{
		18		/// <summary> The Deployments service client. </summary>
		19		public partial class DeploymentsOperations
		20		{
		21		private readonly ClientDiagnostics _clientDiagnostics;
		22		private readonly HttpPipeline _pipeline;
	412	23		internal DeploymentsRestOperations RestClient { get; }
		24		/// <summary> Initializes a new instance of DeploymentsOperations for mocking. </summary>
	352	25		protected DeploymentsOperations()
		26		{
	352	27		}
		28		/// <summary> Initializes a new instance of DeploymentsOperations. </summary>
		29		/// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
		30		/// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
		31		/// <param name="subscriptionId"> The ID of the target subscription. </param>
		32		/// <param name="endpoint"> server parameter. </param>
	352	33		internal DeploymentsOperations(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, string subscriptionId
		34		{
	352	35		RestClient = new DeploymentsRestOperations(clientDiagnostics, pipeline, subscriptionId, endpoint);
	352	36		_clientDiagnostics = clientDiagnostics;
	352	37		_pipeline = pipeline;
	352	38		}
		39
		40		/// <summary> Checks whether the deployment exists. </summary>
		41		/// <param name="scope"> The resource scope. </param>
		42		/// <param name="deploymentName"> The name of the deployment. </param>
		43		/// <param name="cancellationToken"> The cancellation token to use. </param>
		44		public virtual async Task<Response> CheckExistenceAtScopeAsync(string scope, string deploymentName, Cancellation
		45		{
	0	46		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistenceAtScope");
	0	47		scope0.Start();
		48		try
		49		{
	0	50		return await RestClient.CheckExistenceAtScopeAsync(scope, deploymentName, cancellationToken).ConfigureAw
		51		}
	0	52		catch (Exception e)
		53		{
	0	54		scope0.Failed(e);
	0	55		throw;
		56		}
	0	57		}
		58
		59		/// <summary> Checks whether the deployment exists. </summary>
		60		/// <param name="scope"> The resource scope. </param>
		61		/// <param name="deploymentName"> The name of the deployment. </param>
		62		/// <param name="cancellationToken"> The cancellation token to use. </param>
		63		public virtual Response CheckExistenceAtScope(string scope, string deploymentName, CancellationToken cancellatio
		64		{
	0	65		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistenceAtScope");
	0	66		scope0.Start();
		67		try
		68		{
	0	69		return RestClient.CheckExistenceAtScope(scope, deploymentName, cancellationToken);
		70		}
	0	71		catch (Exception e)
		72		{
	0	73		scope0.Failed(e);
	0	74		throw;
		75		}
	0	76		}
		77
		78		/// <summary> Gets a deployment. </summary>
		79		/// <param name="scope"> The resource scope. </param>
		80		/// <param name="deploymentName"> The name of the deployment. </param>
		81		/// <param name="cancellationToken"> The cancellation token to use. </param>
		82		public virtual async Task<Response<DeploymentExtended>> GetAtScopeAsync(string scope, string deploymentName, Can
		83		{
	6	84		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.GetAtScope");
	6	85		scope0.Start();
		86		try
		87		{
	6	88		return await RestClient.GetAtScopeAsync(scope, deploymentName, cancellationToken).ConfigureAwait(false);
		89		}
	0	90		catch (Exception e)
		91		{
	0	92		scope0.Failed(e);
	0	93		throw;
		94		}
	6	95		}
		96
		97		/// <summary> Gets a deployment. </summary>
		98		/// <param name="scope"> The resource scope. </param>
		99		/// <param name="deploymentName"> The name of the deployment. </param>
		100		/// <param name="cancellationToken"> The cancellation token to use. </param>
		101		public virtual Response<DeploymentExtended> GetAtScope(string scope, string deploymentName, CancellationToken ca
		102		{
	6	103		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.GetAtScope");
	6	104		scope0.Start();
		105		try
		106		{
	6	107		return RestClient.GetAtScope(scope, deploymentName, cancellationToken);
		108		}
	0	109		catch (Exception e)
		110		{
	0	111		scope0.Failed(e);
	0	112		throw;
		113		}
	6	114		}
		115
		116		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		117		/// <param name="scope"> The resource scope. </param>
		118		/// <param name="deploymentName"> The name of the deployment. </param>
		119		/// <param name="cancellationToken"> The cancellation token to use. </param>
		120		public virtual async Task<Response> CancelAtScopeAsync(string scope, string deploymentName, CancellationToken ca
		121		{
	0	122		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CancelAtScope");
	0	123		scope0.Start();
		124		try
		125		{
	0	126		return await RestClient.CancelAtScopeAsync(scope, deploymentName, cancellationToken).ConfigureAwait(fals
		127		}
	0	128		catch (Exception e)
		129		{
	0	130		scope0.Failed(e);
	0	131		throw;
		132		}
	0	133		}
		134
		135		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		136		/// <param name="scope"> The resource scope. </param>
		137		/// <param name="deploymentName"> The name of the deployment. </param>
		138		/// <param name="cancellationToken"> The cancellation token to use. </param>
		139		public virtual Response CancelAtScope(string scope, string deploymentName, CancellationToken cancellationToken =
		140		{
	0	141		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CancelAtScope");
	0	142		scope0.Start();
		143		try
		144		{
	0	145		return RestClient.CancelAtScope(scope, deploymentName, cancellationToken);
		146		}
	0	147		catch (Exception e)
		148		{
	0	149		scope0.Failed(e);
	0	150		throw;
		151		}
	0	152		}
		153
		154		/// <summary> Exports the template used for specified deployment. </summary>
		155		/// <param name="scope"> The resource scope. </param>
		156		/// <param name="deploymentName"> The name of the deployment. </param>
		157		/// <param name="cancellationToken"> The cancellation token to use. </param>
		158		public virtual async Task<Response<DeploymentExportResult>> ExportTemplateAtScopeAsync(string scope, string depl
		159		{
	0	160		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplateAtScope");
	0	161		scope0.Start();
		162		try
		163		{
	0	164		return await RestClient.ExportTemplateAtScopeAsync(scope, deploymentName, cancellationToken).ConfigureAw
		165		}
	0	166		catch (Exception e)
		167		{
	0	168		scope0.Failed(e);
	0	169		throw;
		170		}
	0	171		}
		172
		173		/// <summary> Exports the template used for specified deployment. </summary>
		174		/// <param name="scope"> The resource scope. </param>
		175		/// <param name="deploymentName"> The name of the deployment. </param>
		176		/// <param name="cancellationToken"> The cancellation token to use. </param>
		177		public virtual Response<DeploymentExportResult> ExportTemplateAtScope(string scope, string deploymentName, Cance
		178		{
	0	179		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplateAtScope");
	0	180		scope0.Start();
		181		try
		182		{
	0	183		return RestClient.ExportTemplateAtScope(scope, deploymentName, cancellationToken);
		184		}
	0	185		catch (Exception e)
		186		{
	0	187		scope0.Failed(e);
	0	188		throw;
		189		}
	0	190		}
		191
		192		/// <summary> Checks whether the deployment exists. </summary>
		193		/// <param name="deploymentName"> The name of the deployment. </param>
		194		/// <param name="cancellationToken"> The cancellation token to use. </param>
		195		public virtual async Task<Response> CheckExistenceAtTenantScopeAsync(string deploymentName, CancellationToken ca
		196		{
	0	197		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistenceAtTenantScope");
	0	198		scope0.Start();
		199		try
		200		{
	0	201		return await RestClient.CheckExistenceAtTenantScopeAsync(deploymentName, cancellationToken).ConfigureAwa
		202		}
	0	203		catch (Exception e)
		204		{
	0	205		scope0.Failed(e);
	0	206		throw;
		207		}
	0	208		}
		209
		210		/// <summary> Checks whether the deployment exists. </summary>
		211		/// <param name="deploymentName"> The name of the deployment. </param>
		212		/// <param name="cancellationToken"> The cancellation token to use. </param>
		213		public virtual Response CheckExistenceAtTenantScope(string deploymentName, CancellationToken cancellationToken =
		214		{
	0	215		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistenceAtTenantScope");
	0	216		scope0.Start();
		217		try
		218		{
	0	219		return RestClient.CheckExistenceAtTenantScope(deploymentName, cancellationToken);
		220		}
	0	221		catch (Exception e)
		222		{
	0	223		scope0.Failed(e);
	0	224		throw;
		225		}
	0	226		}
		227
		228		/// <summary> Gets a deployment. </summary>
		229		/// <param name="deploymentName"> The name of the deployment. </param>
		230		/// <param name="cancellationToken"> The cancellation token to use. </param>
		231		public virtual async Task<Response<DeploymentExtended>> GetAtTenantScopeAsync(string deploymentName, Cancellatio
		232		{
	0	233		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.GetAtTenantScope");
	0	234		scope0.Start();
		235		try
		236		{
	0	237		return await RestClient.GetAtTenantScopeAsync(deploymentName, cancellationToken).ConfigureAwait(false);
		238		}
	0	239		catch (Exception e)
		240		{
	0	241		scope0.Failed(e);
	0	242		throw;
		243		}
	0	244		}
		245
		246		/// <summary> Gets a deployment. </summary>
		247		/// <param name="deploymentName"> The name of the deployment. </param>
		248		/// <param name="cancellationToken"> The cancellation token to use. </param>
		249		public virtual Response<DeploymentExtended> GetAtTenantScope(string deploymentName, CancellationToken cancellati
		250		{
	0	251		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.GetAtTenantScope");
	0	252		scope0.Start();
		253		try
		254		{
	0	255		return RestClient.GetAtTenantScope(deploymentName, cancellationToken);
		256		}
	0	257		catch (Exception e)
		258		{
	0	259		scope0.Failed(e);
	0	260		throw;
		261		}
	0	262		}
		263
		264		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		265		/// <param name="deploymentName"> The name of the deployment. </param>
		266		/// <param name="cancellationToken"> The cancellation token to use. </param>
		267		public virtual async Task<Response> CancelAtTenantScopeAsync(string deploymentName, CancellationToken cancellati
		268		{
	0	269		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CancelAtTenantScope");
	0	270		scope0.Start();
		271		try
		272		{
	0	273		return await RestClient.CancelAtTenantScopeAsync(deploymentName, cancellationToken).ConfigureAwait(false
		274		}
	0	275		catch (Exception e)
		276		{
	0	277		scope0.Failed(e);
	0	278		throw;
		279		}
	0	280		}
		281
		282		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		283		/// <param name="deploymentName"> The name of the deployment. </param>
		284		/// <param name="cancellationToken"> The cancellation token to use. </param>
		285		public virtual Response CancelAtTenantScope(string deploymentName, CancellationToken cancellationToken = default
		286		{
	0	287		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CancelAtTenantScope");
	0	288		scope0.Start();
		289		try
		290		{
	0	291		return RestClient.CancelAtTenantScope(deploymentName, cancellationToken);
		292		}
	0	293		catch (Exception e)
		294		{
	0	295		scope0.Failed(e);
	0	296		throw;
		297		}
	0	298		}
		299
		300		/// <summary> Exports the template used for specified deployment. </summary>
		301		/// <param name="deploymentName"> The name of the deployment. </param>
		302		/// <param name="cancellationToken"> The cancellation token to use. </param>
		303		public virtual async Task<Response<DeploymentExportResult>> ExportTemplateAtTenantScopeAsync(string deploymentNa
		304		{
	0	305		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplateAtTenantScope");
	0	306		scope0.Start();
		307		try
		308		{
	0	309		return await RestClient.ExportTemplateAtTenantScopeAsync(deploymentName, cancellationToken).ConfigureAwa
		310		}
	0	311		catch (Exception e)
		312		{
	0	313		scope0.Failed(e);
	0	314		throw;
		315		}
	0	316		}
		317
		318		/// <summary> Exports the template used for specified deployment. </summary>
		319		/// <param name="deploymentName"> The name of the deployment. </param>
		320		/// <param name="cancellationToken"> The cancellation token to use. </param>
		321		public virtual Response<DeploymentExportResult> ExportTemplateAtTenantScope(string deploymentName, CancellationT
		322		{
	0	323		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplateAtTenantScope");
	0	324		scope0.Start();
		325		try
		326		{
	0	327		return RestClient.ExportTemplateAtTenantScope(deploymentName, cancellationToken);
		328		}
	0	329		catch (Exception e)
		330		{
	0	331		scope0.Failed(e);
	0	332		throw;
		333		}
	0	334		}
		335
		336		/// <summary> Checks whether the deployment exists. </summary>
		337		/// <param name="groupId"> The management group ID. </param>
		338		/// <param name="deploymentName"> The name of the deployment. </param>
		339		/// <param name="cancellationToken"> The cancellation token to use. </param>
		340		public virtual async Task<Response> CheckExistenceAtManagementGroupScopeAsync(string groupId, string deploymentN
		341		{
	0	342		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistenceAtManagementGroupScop
	0	343		scope0.Start();
		344		try
		345		{
	0	346		return await RestClient.CheckExistenceAtManagementGroupScopeAsync(groupId, deploymentName, cancellationT
		347		}
	0	348		catch (Exception e)
		349		{
	0	350		scope0.Failed(e);
	0	351		throw;
		352		}
	0	353		}
		354
		355		/// <summary> Checks whether the deployment exists. </summary>
		356		/// <param name="groupId"> The management group ID. </param>
		357		/// <param name="deploymentName"> The name of the deployment. </param>
		358		/// <param name="cancellationToken"> The cancellation token to use. </param>
		359		public virtual Response CheckExistenceAtManagementGroupScope(string groupId, string deploymentName, Cancellation
		360		{
	0	361		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistenceAtManagementGroupScop
	0	362		scope0.Start();
		363		try
		364		{
	0	365		return RestClient.CheckExistenceAtManagementGroupScope(groupId, deploymentName, cancellationToken);
		366		}
	0	367		catch (Exception e)
		368		{
	0	369		scope0.Failed(e);
	0	370		throw;
		371		}
	0	372		}
		373
		374		/// <summary> Gets a deployment. </summary>
		375		/// <param name="groupId"> The management group ID. </param>
		376		/// <param name="deploymentName"> The name of the deployment. </param>
		377		/// <param name="cancellationToken"> The cancellation token to use. </param>
		378		public virtual async Task<Response<DeploymentExtended>> GetAtManagementGroupScopeAsync(string groupId, string de
		379		{
	2	380		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.GetAtManagementGroupScope");
	2	381		scope0.Start();
		382		try
		383		{
	2	384		return await RestClient.GetAtManagementGroupScopeAsync(groupId, deploymentName, cancellationToken).Confi
		385		}
	0	386		catch (Exception e)
		387		{
	0	388		scope0.Failed(e);
	0	389		throw;
		390		}
	2	391		}
		392
		393		/// <summary> Gets a deployment. </summary>
		394		/// <param name="groupId"> The management group ID. </param>
		395		/// <param name="deploymentName"> The name of the deployment. </param>
		396		/// <param name="cancellationToken"> The cancellation token to use. </param>
		397		public virtual Response<DeploymentExtended> GetAtManagementGroupScope(string groupId, string deploymentName, Can
		398		{
	2	399		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.GetAtManagementGroupScope");
	2	400		scope0.Start();
		401		try
		402		{
	2	403		return RestClient.GetAtManagementGroupScope(groupId, deploymentName, cancellationToken);
		404		}
	0	405		catch (Exception e)
		406		{
	0	407		scope0.Failed(e);
	0	408		throw;
		409		}
	2	410		}
		411
		412		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		413		/// <param name="groupId"> The management group ID. </param>
		414		/// <param name="deploymentName"> The name of the deployment. </param>
		415		/// <param name="cancellationToken"> The cancellation token to use. </param>
		416		public virtual async Task<Response> CancelAtManagementGroupScopeAsync(string groupId, string deploymentName, Can
		417		{
	0	418		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CancelAtManagementGroupScope");
	0	419		scope0.Start();
		420		try
		421		{
	0	422		return await RestClient.CancelAtManagementGroupScopeAsync(groupId, deploymentName, cancellationToken).Co
		423		}
	0	424		catch (Exception e)
		425		{
	0	426		scope0.Failed(e);
	0	427		throw;
		428		}
	0	429		}
		430
		431		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		432		/// <param name="groupId"> The management group ID. </param>
		433		/// <param name="deploymentName"> The name of the deployment. </param>
		434		/// <param name="cancellationToken"> The cancellation token to use. </param>
		435		public virtual Response CancelAtManagementGroupScope(string groupId, string deploymentName, CancellationToken ca
		436		{
	0	437		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CancelAtManagementGroupScope");
	0	438		scope0.Start();
		439		try
		440		{
	0	441		return RestClient.CancelAtManagementGroupScope(groupId, deploymentName, cancellationToken);
		442		}
	0	443		catch (Exception e)
		444		{
	0	445		scope0.Failed(e);
	0	446		throw;
		447		}
	0	448		}
		449
		450		/// <summary> Exports the template used for specified deployment. </summary>
		451		/// <param name="groupId"> The management group ID. </param>
		452		/// <param name="deploymentName"> The name of the deployment. </param>
		453		/// <param name="cancellationToken"> The cancellation token to use. </param>
		454		public virtual async Task<Response<DeploymentExportResult>> ExportTemplateAtManagementGroupScopeAsync(string gro
		455		{
	0	456		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplateAtManagementGroupScop
	0	457		scope0.Start();
		458		try
		459		{
	0	460		return await RestClient.ExportTemplateAtManagementGroupScopeAsync(groupId, deploymentName, cancellationT
		461		}
	0	462		catch (Exception e)
		463		{
	0	464		scope0.Failed(e);
	0	465		throw;
		466		}
	0	467		}
		468
		469		/// <summary> Exports the template used for specified deployment. </summary>
		470		/// <param name="groupId"> The management group ID. </param>
		471		/// <param name="deploymentName"> The name of the deployment. </param>
		472		/// <param name="cancellationToken"> The cancellation token to use. </param>
		473		public virtual Response<DeploymentExportResult> ExportTemplateAtManagementGroupScope(string groupId, string depl
		474		{
	0	475		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplateAtManagementGroupScop
	0	476		scope0.Start();
		477		try
		478		{
	0	479		return RestClient.ExportTemplateAtManagementGroupScope(groupId, deploymentName, cancellationToken);
		480		}
	0	481		catch (Exception e)
		482		{
	0	483		scope0.Failed(e);
	0	484		throw;
		485		}
	0	486		}
		487
		488		/// <summary> Checks whether the deployment exists. </summary>
		489		/// <param name="deploymentName"> The name of the deployment. </param>
		490		/// <param name="cancellationToken"> The cancellation token to use. </param>
		491		public virtual async Task<Response> CheckExistenceAtSubscriptionScopeAsync(string deploymentName, CancellationTo
		492		{
	0	493		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistenceAtSubscriptionScope")
	0	494		scope0.Start();
		495		try
		496		{
	0	497		return await RestClient.CheckExistenceAtSubscriptionScopeAsync(deploymentName, cancellationToken).Config
		498		}
	0	499		catch (Exception e)
		500		{
	0	501		scope0.Failed(e);
	0	502		throw;
		503		}
	0	504		}
		505
		506		/// <summary> Checks whether the deployment exists. </summary>
		507		/// <param name="deploymentName"> The name of the deployment. </param>
		508		/// <param name="cancellationToken"> The cancellation token to use. </param>
		509		public virtual Response CheckExistenceAtSubscriptionScope(string deploymentName, CancellationToken cancellationT
		510		{
	0	511		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistenceAtSubscriptionScope")
	0	512		scope0.Start();
		513		try
		514		{
	0	515		return RestClient.CheckExistenceAtSubscriptionScope(deploymentName, cancellationToken);
		516		}
	0	517		catch (Exception e)
		518		{
	0	519		scope0.Failed(e);
	0	520		throw;
		521		}
	0	522		}
		523
		524		/// <summary> Gets a deployment. </summary>
		525		/// <param name="deploymentName"> The name of the deployment. </param>
		526		/// <param name="cancellationToken"> The cancellation token to use. </param>
		527		public virtual async Task<Response<DeploymentExtended>> GetAtSubscriptionScopeAsync(string deploymentName, Cance
		528		{
	2	529		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.GetAtSubscriptionScope");
	2	530		scope0.Start();
		531		try
		532		{
	2	533		return await RestClient.GetAtSubscriptionScopeAsync(deploymentName, cancellationToken).ConfigureAwait(fa
		534		}
	0	535		catch (Exception e)
		536		{
	0	537		scope0.Failed(e);
	0	538		throw;
		539		}
	2	540		}
		541
		542		/// <summary> Gets a deployment. </summary>
		543		/// <param name="deploymentName"> The name of the deployment. </param>
		544		/// <param name="cancellationToken"> The cancellation token to use. </param>
		545		public virtual Response<DeploymentExtended> GetAtSubscriptionScope(string deploymentName, CancellationToken canc
		546		{
	2	547		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.GetAtSubscriptionScope");
	2	548		scope0.Start();
		549		try
		550		{
	2	551		return RestClient.GetAtSubscriptionScope(deploymentName, cancellationToken);
		552		}
	0	553		catch (Exception e)
		554		{
	0	555		scope0.Failed(e);
	0	556		throw;
		557		}
	2	558		}
		559
		560		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		561		/// <param name="deploymentName"> The name of the deployment. </param>
		562		/// <param name="cancellationToken"> The cancellation token to use. </param>
		563		public virtual async Task<Response> CancelAtSubscriptionScopeAsync(string deploymentName, CancellationToken canc
		564		{
	0	565		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CancelAtSubscriptionScope");
	0	566		scope0.Start();
		567		try
		568		{
	0	569		return await RestClient.CancelAtSubscriptionScopeAsync(deploymentName, cancellationToken).ConfigureAwait
		570		}
	0	571		catch (Exception e)
		572		{
	0	573		scope0.Failed(e);
	0	574		throw;
		575		}
	0	576		}
		577
		578		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		579		/// <param name="deploymentName"> The name of the deployment. </param>
		580		/// <param name="cancellationToken"> The cancellation token to use. </param>
		581		public virtual Response CancelAtSubscriptionScope(string deploymentName, CancellationToken cancellationToken = d
		582		{
	0	583		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CancelAtSubscriptionScope");
	0	584		scope0.Start();
		585		try
		586		{
	0	587		return RestClient.CancelAtSubscriptionScope(deploymentName, cancellationToken);
		588		}
	0	589		catch (Exception e)
		590		{
	0	591		scope0.Failed(e);
	0	592		throw;
		593		}
	0	594		}
		595
		596		/// <summary> Exports the template used for specified deployment. </summary>
		597		/// <param name="deploymentName"> The name of the deployment. </param>
		598		/// <param name="cancellationToken"> The cancellation token to use. </param>
		599		public virtual async Task<Response<DeploymentExportResult>> ExportTemplateAtSubscriptionScopeAsync(string deploy
		600		{
	0	601		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplateAtSubscriptionScope")
	0	602		scope0.Start();
		603		try
		604		{
	0	605		return await RestClient.ExportTemplateAtSubscriptionScopeAsync(deploymentName, cancellationToken).Config
		606		}
	0	607		catch (Exception e)
		608		{
	0	609		scope0.Failed(e);
	0	610		throw;
		611		}
	0	612		}
		613
		614		/// <summary> Exports the template used for specified deployment. </summary>
		615		/// <param name="deploymentName"> The name of the deployment. </param>
		616		/// <param name="cancellationToken"> The cancellation token to use. </param>
		617		public virtual Response<DeploymentExportResult> ExportTemplateAtSubscriptionScope(string deploymentName, Cancell
		618		{
	0	619		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplateAtSubscriptionScope")
	0	620		scope0.Start();
		621		try
		622		{
	0	623		return RestClient.ExportTemplateAtSubscriptionScope(deploymentName, cancellationToken);
		624		}
	0	625		catch (Exception e)
		626		{
	0	627		scope0.Failed(e);
	0	628		throw;
		629		}
	0	630		}
		631
		632		/// <summary> Checks whether the deployment exists. </summary>
		633		/// <param name="resourceGroupName"> The name of the resource group with the deployment to check. The name is ca
		634		/// <param name="deploymentName"> The name of the deployment. </param>
		635		/// <param name="cancellationToken"> The cancellation token to use. </param>
		636		public virtual async Task<Response> CheckExistenceAsync(string resourceGroupName, string deploymentName, Cancell
		637		{
	0	638		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistence");
	0	639		scope0.Start();
		640		try
		641		{
	0	642		return await RestClient.CheckExistenceAsync(resourceGroupName, deploymentName, cancellationToken).Config
		643		}
	0	644		catch (Exception e)
		645		{
	0	646		scope0.Failed(e);
	0	647		throw;
		648		}
	0	649		}
		650
		651		/// <summary> Checks whether the deployment exists. </summary>
		652		/// <param name="resourceGroupName"> The name of the resource group with the deployment to check. The name is ca
		653		/// <param name="deploymentName"> The name of the deployment. </param>
		654		/// <param name="cancellationToken"> The cancellation token to use. </param>
		655		public virtual Response CheckExistence(string resourceGroupName, string deploymentName, CancellationToken cancel
		656		{
	0	657		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CheckExistence");
	0	658		scope0.Start();
		659		try
		660		{
	0	661		return RestClient.CheckExistence(resourceGroupName, deploymentName, cancellationToken);
		662		}
	0	663		catch (Exception e)
		664		{
	0	665		scope0.Failed(e);
	0	666		throw;
		667		}
	0	668		}
		669
		670		/// <summary> Gets a deployment. </summary>
		671		/// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
		672		/// <param name="deploymentName"> The name of the deployment. </param>
		673		/// <param name="cancellationToken"> The cancellation token to use. </param>
		674		public virtual async Task<Response<DeploymentExtended>> GetAsync(string resourceGroupName, string deploymentName
		675		{
	6	676		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.Get");
	6	677		scope0.Start();
		678		try
		679		{
	6	680		return await RestClient.GetAsync(resourceGroupName, deploymentName, cancellationToken).ConfigureAwait(fa
		681		}
	0	682		catch (Exception e)
		683		{
	0	684		scope0.Failed(e);
	0	685		throw;
		686		}
	6	687		}
		688
		689		/// <summary> Gets a deployment. </summary>
		690		/// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
		691		/// <param name="deploymentName"> The name of the deployment. </param>
		692		/// <param name="cancellationToken"> The cancellation token to use. </param>
		693		public virtual Response<DeploymentExtended> Get(string resourceGroupName, string deploymentName, CancellationTok
		694		{
	6	695		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.Get");
	6	696		scope0.Start();
		697		try
		698		{
	6	699		return RestClient.Get(resourceGroupName, deploymentName, cancellationToken);
		700		}
	0	701		catch (Exception e)
		702		{
	0	703		scope0.Failed(e);
	0	704		throw;
		705		}
	6	706		}
		707
		708		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		709		/// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
		710		/// <param name="deploymentName"> The name of the deployment. </param>
		711		/// <param name="cancellationToken"> The cancellation token to use. </param>
		712		public virtual async Task<Response> CancelAsync(string resourceGroupName, string deploymentName, CancellationTok
		713		{
	6	714		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.Cancel");
	6	715		scope0.Start();
		716		try
		717		{
	6	718		return await RestClient.CancelAsync(resourceGroupName, deploymentName, cancellationToken).ConfigureAwait
		719		}
	4	720		catch (Exception e)
		721		{
	4	722		scope0.Failed(e);
	4	723		throw;
		724		}
	2	725		}
		726
		727		/// <summary> You can cancel a deployment only if the provisioningState is Accepted or Running. After the deploy
		728		/// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
		729		/// <param name="deploymentName"> The name of the deployment. </param>
		730		/// <param name="cancellationToken"> The cancellation token to use. </param>
		731		public virtual Response Cancel(string resourceGroupName, string deploymentName, CancellationToken cancellationTo
		732		{
	6	733		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.Cancel");
	6	734		scope0.Start();
		735		try
		736		{
	6	737		return RestClient.Cancel(resourceGroupName, deploymentName, cancellationToken);
		738		}
	4	739		catch (Exception e)
		740		{
	4	741		scope0.Failed(e);
	4	742		throw;
		743		}
	2	744		}
		745
		746		/// <summary> Exports the template used for specified deployment. </summary>
		747		/// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
		748		/// <param name="deploymentName"> The name of the deployment. </param>
		749		/// <param name="cancellationToken"> The cancellation token to use. </param>
		750		public virtual async Task<Response<DeploymentExportResult>> ExportTemplateAsync(string resourceGroupName, string
		751		{
	0	752		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplate");
	0	753		scope0.Start();
		754		try
		755		{
	0	756		return await RestClient.ExportTemplateAsync(resourceGroupName, deploymentName, cancellationToken).Config
		757		}
	0	758		catch (Exception e)
		759		{
	0	760		scope0.Failed(e);
	0	761		throw;
		762		}
	0	763		}
		764
		765		/// <summary> Exports the template used for specified deployment. </summary>
		766		/// <param name="resourceGroupName"> The name of the resource group. The name is case insensitive. </param>
		767		/// <param name="deploymentName"> The name of the deployment. </param>
		768		/// <param name="cancellationToken"> The cancellation token to use. </param>
		769		public virtual Response<DeploymentExportResult> ExportTemplate(string resourceGroupName, string deploymentName,
		770		{
	0	771		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ExportTemplate");
	0	772		scope0.Start();
		773		try
		774		{
	0	775		return RestClient.ExportTemplate(resourceGroupName, deploymentName, cancellationToken);
		776		}
	0	777		catch (Exception e)
		778		{
	0	779		scope0.Failed(e);
	0	780		throw;
		781		}
	0	782		}
		783
		784		/// <summary> Calculate the hash of the given template. </summary>
		785		/// <param name="template"> The template provided to calculate hash. </param>
		786		/// <param name="cancellationToken"> The cancellation token to use. </param>
		787		public virtual async Task<Response<TemplateHashResult>> CalculateTemplateHashAsync(object template, Cancellation
		788		{
	0	789		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CalculateTemplateHash");
	0	790		scope0.Start();
		791		try
		792		{
	0	793		return await RestClient.CalculateTemplateHashAsync(template, cancellationToken).ConfigureAwait(false);
		794		}
	0	795		catch (Exception e)
		796		{
	0	797		scope0.Failed(e);
	0	798		throw;
		799		}
	0	800		}
		801
		802		/// <summary> Calculate the hash of the given template. </summary>
		803		/// <param name="template"> The template provided to calculate hash. </param>
		804		/// <param name="cancellationToken"> The cancellation token to use. </param>
		805		public virtual Response<TemplateHashResult> CalculateTemplateHash(object template, CancellationToken cancellatio
		806		{
	0	807		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.CalculateTemplateHash");
	0	808		scope0.Start();
		809		try
		810		{
	0	811		return RestClient.CalculateTemplateHash(template, cancellationToken);
		812		}
	0	813		catch (Exception e)
		814		{
	0	815		scope0.Failed(e);
	0	816		throw;
		817		}
	0	818		}
		819
		820		/// <summary> Get all the deployments at the given scope. </summary>
		821		/// <param name="scope"> The resource scope. </param>
		822		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		823		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		824		/// <param name="cancellationToken"> The cancellation token to use. </param>
		825		public virtual AsyncPageable<DeploymentExtended> ListAtScopeAsync(string scope, string filter = null, int? top =
		826		{
	0	827		if (scope == null)
		828		{
	0	829		throw new ArgumentNullException(nameof(scope));
		830		}
		831
		832		async Task<Page<DeploymentExtended>> FirstPageFunc(int? pageSizeHint)
		833		{
	0	834		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtScope");
	0	835		scope0.Start();
		836		try
		837		{
	0	838		var response = await RestClient.ListAtScopeAsync(scope, filter, top, cancellationToken).ConfigureAwa
	0	839		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		840		}
	0	841		catch (Exception e)
		842		{
	0	843		scope0.Failed(e);
	0	844		throw;
		845		}
	0	846		}
		847		async Task<Page<DeploymentExtended>> NextPageFunc(string nextLink, int? pageSizeHint)
		848		{
	0	849		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtScope");
	0	850		scope0.Start();
		851		try
		852		{
	0	853		var response = await RestClient.ListAtScopeNextPageAsync(nextLink, scope, filter, top, cancellationT
	0	854		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		855		}
	0	856		catch (Exception e)
		857		{
	0	858		scope0.Failed(e);
	0	859		throw;
		860		}
	0	861		}
	0	862		return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, NextPageFunc);
		863		}
		864
		865		/// <summary> Get all the deployments at the given scope. </summary>
		866		/// <param name="scope"> The resource scope. </param>
		867		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		868		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		869		/// <param name="cancellationToken"> The cancellation token to use. </param>
		870		public virtual Pageable<DeploymentExtended> ListAtScope(string scope, string filter = null, int? top = null, Can
		871		{
	0	872		if (scope == null)
		873		{
	0	874		throw new ArgumentNullException(nameof(scope));
		875		}
		876
		877		Page<DeploymentExtended> FirstPageFunc(int? pageSizeHint)
		878		{
	0	879		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtScope");
	0	880		scope0.Start();
		881		try
		882		{
	0	883		var response = RestClient.ListAtScope(scope, filter, top, cancellationToken);
	0	884		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		885		}
	0	886		catch (Exception e)
		887		{
	0	888		scope0.Failed(e);
	0	889		throw;
		890		}
	0	891		}
		892		Page<DeploymentExtended> NextPageFunc(string nextLink, int? pageSizeHint)
		893		{
	0	894		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtScope");
	0	895		scope0.Start();
		896		try
		897		{
	0	898		var response = RestClient.ListAtScopeNextPage(nextLink, scope, filter, top, cancellationToken);
	0	899		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		900		}
	0	901		catch (Exception e)
		902		{
	0	903		scope0.Failed(e);
	0	904		throw;
		905		}
	0	906		}
	0	907		return PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc);
		908		}
		909
		910		/// <summary> Get all the deployments at the tenant scope. </summary>
		911		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		912		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		913		/// <param name="cancellationToken"> The cancellation token to use. </param>
		914		public virtual AsyncPageable<DeploymentExtended> ListAtTenantScopeAsync(string filter = null, int? top = null, C
		915		{
		916		async Task<Page<DeploymentExtended>> FirstPageFunc(int? pageSizeHint)
		917		{
	0	918		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtTenantScope");
	0	919		scope0.Start();
		920		try
		921		{
	0	922		var response = await RestClient.ListAtTenantScopeAsync(filter, top, cancellationToken).ConfigureAwai
	0	923		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		924		}
	0	925		catch (Exception e)
		926		{
	0	927		scope0.Failed(e);
	0	928		throw;
		929		}
	0	930		}
		931		async Task<Page<DeploymentExtended>> NextPageFunc(string nextLink, int? pageSizeHint)
		932		{
	0	933		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtTenantScope");
	0	934		scope0.Start();
		935		try
		936		{
	0	937		var response = await RestClient.ListAtTenantScopeNextPageAsync(nextLink, filter, top, cancellationTo
	0	938		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		939		}
	0	940		catch (Exception e)
		941		{
	0	942		scope0.Failed(e);
	0	943		throw;
		944		}
	0	945		}
	0	946		return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, NextPageFunc);
		947		}
		948
		949		/// <summary> Get all the deployments at the tenant scope. </summary>
		950		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		951		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		952		/// <param name="cancellationToken"> The cancellation token to use. </param>
		953		public virtual Pageable<DeploymentExtended> ListAtTenantScope(string filter = null, int? top = null, Cancellatio
		954		{
		955		Page<DeploymentExtended> FirstPageFunc(int? pageSizeHint)
		956		{
	0	957		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtTenantScope");
	0	958		scope0.Start();
		959		try
		960		{
	0	961		var response = RestClient.ListAtTenantScope(filter, top, cancellationToken);
	0	962		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		963		}
	0	964		catch (Exception e)
		965		{
	0	966		scope0.Failed(e);
	0	967		throw;
		968		}
	0	969		}
		970		Page<DeploymentExtended> NextPageFunc(string nextLink, int? pageSizeHint)
		971		{
	0	972		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtTenantScope");
	0	973		scope0.Start();
		974		try
		975		{
	0	976		var response = RestClient.ListAtTenantScopeNextPage(nextLink, filter, top, cancellationToken);
	0	977		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		978		}
	0	979		catch (Exception e)
		980		{
	0	981		scope0.Failed(e);
	0	982		throw;
		983		}
	0	984		}
	0	985		return PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc);
		986		}
		987
		988		/// <summary> Get all the deployments for a management group. </summary>
		989		/// <param name="groupId"> The management group ID. </param>
		990		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		991		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		992		/// <param name="cancellationToken"> The cancellation token to use. </param>
		993		public virtual AsyncPageable<DeploymentExtended> ListAtManagementGroupScopeAsync(string groupId, string filter =
		994		{
	0	995		if (groupId == null)
		996		{
	0	997		throw new ArgumentNullException(nameof(groupId));
		998		}
		999
		1000		async Task<Page<DeploymentExtended>> FirstPageFunc(int? pageSizeHint)
		1001		{
	0	1002		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtManagementGroupScope");
	0	1003		scope0.Start();
		1004		try
		1005		{
	0	1006		var response = await RestClient.ListAtManagementGroupScopeAsync(groupId, filter, top, cancellationTo
	0	1007		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1008		}
	0	1009		catch (Exception e)
		1010		{
	0	1011		scope0.Failed(e);
	0	1012		throw;
		1013		}
	0	1014		}
		1015		async Task<Page<DeploymentExtended>> NextPageFunc(string nextLink, int? pageSizeHint)
		1016		{
	0	1017		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtManagementGroupScope");
	0	1018		scope0.Start();
		1019		try
		1020		{
	0	1021		var response = await RestClient.ListAtManagementGroupScopeNextPageAsync(nextLink, groupId, filter, t
	0	1022		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1023		}
	0	1024		catch (Exception e)
		1025		{
	0	1026		scope0.Failed(e);
	0	1027		throw;
		1028		}
	0	1029		}
	0	1030		return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, NextPageFunc);
		1031		}
		1032
		1033		/// <summary> Get all the deployments for a management group. </summary>
		1034		/// <param name="groupId"> The management group ID. </param>
		1035		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		1036		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		1037		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1038		public virtual Pageable<DeploymentExtended> ListAtManagementGroupScope(string groupId, string filter = null, int
		1039		{
	0	1040		if (groupId == null)
		1041		{
	0	1042		throw new ArgumentNullException(nameof(groupId));
		1043		}
		1044
		1045		Page<DeploymentExtended> FirstPageFunc(int? pageSizeHint)
		1046		{
	0	1047		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtManagementGroupScope");
	0	1048		scope0.Start();
		1049		try
		1050		{
	0	1051		var response = RestClient.ListAtManagementGroupScope(groupId, filter, top, cancellationToken);
	0	1052		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1053		}
	0	1054		catch (Exception e)
		1055		{
	0	1056		scope0.Failed(e);
	0	1057		throw;
		1058		}
	0	1059		}
		1060		Page<DeploymentExtended> NextPageFunc(string nextLink, int? pageSizeHint)
		1061		{
	0	1062		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtManagementGroupScope");
	0	1063		scope0.Start();
		1064		try
		1065		{
	0	1066		var response = RestClient.ListAtManagementGroupScopeNextPage(nextLink, groupId, filter, top, cancell
	0	1067		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1068		}
	0	1069		catch (Exception e)
		1070		{
	0	1071		scope0.Failed(e);
	0	1072		throw;
		1073		}
	0	1074		}
	0	1075		return PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc);
		1076		}
		1077
		1078		/// <summary> Get all the deployments for a subscription. </summary>
		1079		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		1080		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		1081		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1082		public virtual AsyncPageable<DeploymentExtended> ListAtSubscriptionScopeAsync(string filter = null, int? top = n
		1083		{
		1084		async Task<Page<DeploymentExtended>> FirstPageFunc(int? pageSizeHint)
		1085		{
	0	1086		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtSubscriptionScope");
	0	1087		scope0.Start();
		1088		try
		1089		{
	0	1090		var response = await RestClient.ListAtSubscriptionScopeAsync(filter, top, cancellationToken).Configu
	0	1091		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1092		}
	0	1093		catch (Exception e)
		1094		{
	0	1095		scope0.Failed(e);
	0	1096		throw;
		1097		}
	0	1098		}
		1099		async Task<Page<DeploymentExtended>> NextPageFunc(string nextLink, int? pageSizeHint)
		1100		{
	0	1101		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtSubscriptionScope");
	0	1102		scope0.Start();
		1103		try
		1104		{
	0	1105		var response = await RestClient.ListAtSubscriptionScopeNextPageAsync(nextLink, filter, top, cancella
	0	1106		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1107		}
	0	1108		catch (Exception e)
		1109		{
	0	1110		scope0.Failed(e);
	0	1111		throw;
		1112		}
	0	1113		}
	0	1114		return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, NextPageFunc);
		1115		}
		1116
		1117		/// <summary> Get all the deployments for a subscription. </summary>
		1118		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		1119		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		1120		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1121		public virtual Pageable<DeploymentExtended> ListAtSubscriptionScope(string filter = null, int? top = null, Cance
		1122		{
		1123		Page<DeploymentExtended> FirstPageFunc(int? pageSizeHint)
		1124		{
	0	1125		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtSubscriptionScope");
	0	1126		scope0.Start();
		1127		try
		1128		{
	0	1129		var response = RestClient.ListAtSubscriptionScope(filter, top, cancellationToken);
	0	1130		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1131		}
	0	1132		catch (Exception e)
		1133		{
	0	1134		scope0.Failed(e);
	0	1135		throw;
		1136		}
	0	1137		}
		1138		Page<DeploymentExtended> NextPageFunc(string nextLink, int? pageSizeHint)
		1139		{
	0	1140		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListAtSubscriptionScope");
	0	1141		scope0.Start();
		1142		try
		1143		{
	0	1144		var response = RestClient.ListAtSubscriptionScopeNextPage(nextLink, filter, top, cancellationToken);
	0	1145		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1146		}
	0	1147		catch (Exception e)
		1148		{
	0	1149		scope0.Failed(e);
	0	1150		throw;
		1151		}
	0	1152		}
	0	1153		return PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc);
		1154		}
		1155
		1156		/// <summary> Get all the deployments for a resource group. </summary>
		1157		/// <param name="resourceGroupName"> The name of the resource group with the deployments to get. The name is cas
		1158		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		1159		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		1160		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1161		public virtual AsyncPageable<DeploymentExtended> ListByResourceGroupAsync(string resourceGroupName, string filte
		1162		{
	8	1163		if (resourceGroupName == null)
		1164		{
	0	1165		throw new ArgumentNullException(nameof(resourceGroupName));
		1166		}
		1167
		1168		async Task<Page<DeploymentExtended>> FirstPageFunc(int? pageSizeHint)
		1169		{
	8	1170		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListByResourceGroup");
	8	1171		scope0.Start();
		1172		try
		1173		{
	8	1174		var response = await RestClient.ListByResourceGroupAsync(resourceGroupName, filter, top, cancellatio
	8	1175		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1176		}
	0	1177		catch (Exception e)
		1178		{
	0	1179		scope0.Failed(e);
	0	1180		throw;
		1181		}
	8	1182		}
		1183		async Task<Page<DeploymentExtended>> NextPageFunc(string nextLink, int? pageSizeHint)
		1184		{
	0	1185		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListByResourceGroup");
	0	1186		scope0.Start();
		1187		try
		1188		{
	0	1189		var response = await RestClient.ListByResourceGroupNextPageAsync(nextLink, resourceGroupName, filter
	0	1190		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1191		}
	0	1192		catch (Exception e)
		1193		{
	0	1194		scope0.Failed(e);
	0	1195		throw;
		1196		}
	0	1197		}
	8	1198		return PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, NextPageFunc);
		1199		}
		1200
		1201		/// <summary> Get all the deployments for a resource group. </summary>
		1202		/// <param name="resourceGroupName"> The name of the resource group with the deployments to get. The name is cas
		1203		/// <param name="filter"> The filter to apply on the operation. For example, you can use $filter=provisioningSta
		1204		/// <param name="top"> The number of results to get. If null is passed, returns all deployments. </param>
		1205		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1206		public virtual Pageable<DeploymentExtended> ListByResourceGroup(string resourceGroupName, string filter = null,
		1207		{
	8	1208		if (resourceGroupName == null)
		1209		{
	0	1210		throw new ArgumentNullException(nameof(resourceGroupName));
		1211		}
		1212
		1213		Page<DeploymentExtended> FirstPageFunc(int? pageSizeHint)
		1214		{
	8	1215		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListByResourceGroup");
	8	1216		scope0.Start();
		1217		try
		1218		{
	8	1219		var response = RestClient.ListByResourceGroup(resourceGroupName, filter, top, cancellationToken);
	8	1220		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1221		}
	0	1222		catch (Exception e)
		1223		{
	0	1224		scope0.Failed(e);
	0	1225		throw;
		1226		}
	8	1227		}
		1228		Page<DeploymentExtended> NextPageFunc(string nextLink, int? pageSizeHint)
		1229		{
	0	1230		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.ListByResourceGroup");
	0	1231		scope0.Start();
		1232		try
		1233		{
	0	1234		var response = RestClient.ListByResourceGroupNextPage(nextLink, resourceGroupName, filter, top, canc
	0	1235		return Page.FromValues(response.Value.Value, response.Value.NextLink, response.GetRawResponse());
		1236		}
	0	1237		catch (Exception e)
		1238		{
	0	1239		scope0.Failed(e);
	0	1240		throw;
		1241		}
	0	1242		}
	8	1243		return PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc);
		1244		}
		1245
		1246		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		1247		/// <param name="scope"> The resource scope. </param>
		1248		/// <param name="deploymentName"> The name of the deployment. </param>
		1249		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1250		public virtual async Task<DeploymentsDeleteAtScopeOperation> StartDeleteAtScopeAsync(string scope, string deploy
		1251		{
	0	1252		if (scope == null)
		1253		{
	0	1254		throw new ArgumentNullException(nameof(scope));
		1255		}
	0	1256		if (deploymentName == null)
		1257		{
	0	1258		throw new ArgumentNullException(nameof(deploymentName));
		1259		}
		1260
	0	1261		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDeleteAtScope");
	0	1262		scope0.Start();
		1263		try
		1264		{
	0	1265		var originalResponse = await RestClient.DeleteAtScopeAsync(scope, deploymentName, cancellationToken).Con
	0	1266		return new DeploymentsDeleteAtScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateDeleteAtSco
		1267		}
	0	1268		catch (Exception e)
		1269		{
	0	1270		scope0.Failed(e);
	0	1271		throw;
		1272		}
	0	1273		}
		1274
		1275		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		1276		/// <param name="scope"> The resource scope. </param>
		1277		/// <param name="deploymentName"> The name of the deployment. </param>
		1278		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1279		public virtual DeploymentsDeleteAtScopeOperation StartDeleteAtScope(string scope, string deploymentName, Cancell
		1280		{
	0	1281		if (scope == null)
		1282		{
	0	1283		throw new ArgumentNullException(nameof(scope));
		1284		}
	0	1285		if (deploymentName == null)
		1286		{
	0	1287		throw new ArgumentNullException(nameof(deploymentName));
		1288		}
		1289
	0	1290		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDeleteAtScope");
	0	1291		scope0.Start();
		1292		try
		1293		{
	0	1294		var originalResponse = RestClient.DeleteAtScope(scope, deploymentName, cancellationToken);
	0	1295		return new DeploymentsDeleteAtScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateDeleteAtSco
		1296		}
	0	1297		catch (Exception e)
		1298		{
	0	1299		scope0.Failed(e);
	0	1300		throw;
		1301		}
	0	1302		}
		1303
		1304		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		1305		/// <param name="scope"> The resource scope. </param>
		1306		/// <param name="deploymentName"> The name of the deployment. </param>
		1307		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		1308		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1309		public virtual async Task<DeploymentsCreateOrUpdateAtScopeOperation> StartCreateOrUpdateAtScopeAsync(string scop
		1310		{
	6	1311		if (scope == null)
		1312		{
	0	1313		throw new ArgumentNullException(nameof(scope));
		1314		}
	6	1315		if (deploymentName == null)
		1316		{
	0	1317		throw new ArgumentNullException(nameof(deploymentName));
		1318		}
	6	1319		if (parameters == null)
		1320		{
	0	1321		throw new ArgumentNullException(nameof(parameters));
		1322		}
		1323
	6	1324		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdateAtScope");
	6	1325		scope0.Start();
		1326		try
		1327		{
	6	1328		var originalResponse = await RestClient.CreateOrUpdateAtScopeAsync(scope, deploymentName, parameters, ca
	6	1329		return new DeploymentsCreateOrUpdateAtScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateCre
		1330		}
	0	1331		catch (Exception e)
		1332		{
	0	1333		scope0.Failed(e);
	0	1334		throw;
		1335		}
	6	1336		}
		1337
		1338		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		1339		/// <param name="scope"> The resource scope. </param>
		1340		/// <param name="deploymentName"> The name of the deployment. </param>
		1341		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		1342		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1343		public virtual DeploymentsCreateOrUpdateAtScopeOperation StartCreateOrUpdateAtScope(string scope, string deploym
		1344		{
	6	1345		if (scope == null)
		1346		{
	0	1347		throw new ArgumentNullException(nameof(scope));
		1348		}
	6	1349		if (deploymentName == null)
		1350		{
	0	1351		throw new ArgumentNullException(nameof(deploymentName));
		1352		}
	6	1353		if (parameters == null)
		1354		{
	0	1355		throw new ArgumentNullException(nameof(parameters));
		1356		}
		1357
	6	1358		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdateAtScope");
	6	1359		scope0.Start();
		1360		try
		1361		{
	6	1362		var originalResponse = RestClient.CreateOrUpdateAtScope(scope, deploymentName, parameters, cancellationT
	6	1363		return new DeploymentsCreateOrUpdateAtScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateCre
		1364		}
	0	1365		catch (Exception e)
		1366		{
	0	1367		scope0.Failed(e);
	0	1368		throw;
		1369		}
	6	1370		}
		1371
		1372		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		1373		/// <param name="scope"> The resource scope. </param>
		1374		/// <param name="deploymentName"> The name of the deployment. </param>
		1375		/// <param name="parameters"> Parameters to validate. </param>
		1376		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1377		public virtual async Task<DeploymentsValidateAtScopeOperation> StartValidateAtScopeAsync(string scope, string de
		1378		{
	6	1379		if (scope == null)
		1380		{
	0	1381		throw new ArgumentNullException(nameof(scope));
		1382		}
	6	1383		if (deploymentName == null)
		1384		{
	0	1385		throw new ArgumentNullException(nameof(deploymentName));
		1386		}
	6	1387		if (parameters == null)
		1388		{
	0	1389		throw new ArgumentNullException(nameof(parameters));
		1390		}
		1391
	6	1392		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidateAtScope");
	6	1393		scope0.Start();
		1394		try
		1395		{
	6	1396		var originalResponse = await RestClient.ValidateAtScopeAsync(scope, deploymentName, parameters, cancella
	6	1397		return new DeploymentsValidateAtScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateValidateA
		1398		}
	0	1399		catch (Exception e)
		1400		{
	0	1401		scope0.Failed(e);
	0	1402		throw;
		1403		}
	6	1404		}
		1405
		1406		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		1407		/// <param name="scope"> The resource scope. </param>
		1408		/// <param name="deploymentName"> The name of the deployment. </param>
		1409		/// <param name="parameters"> Parameters to validate. </param>
		1410		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1411		public virtual DeploymentsValidateAtScopeOperation StartValidateAtScope(string scope, string deploymentName, Dep
		1412		{
	6	1413		if (scope == null)
		1414		{
	0	1415		throw new ArgumentNullException(nameof(scope));
		1416		}
	6	1417		if (deploymentName == null)
		1418		{
	0	1419		throw new ArgumentNullException(nameof(deploymentName));
		1420		}
	6	1421		if (parameters == null)
		1422		{
	0	1423		throw new ArgumentNullException(nameof(parameters));
		1424		}
		1425
	6	1426		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidateAtScope");
	6	1427		scope0.Start();
		1428		try
		1429		{
	6	1430		var originalResponse = RestClient.ValidateAtScope(scope, deploymentName, parameters, cancellationToken);
	6	1431		return new DeploymentsValidateAtScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateValidateA
		1432		}
	0	1433		catch (Exception e)
		1434		{
	0	1435		scope0.Failed(e);
	0	1436		throw;
		1437		}
	6	1438		}
		1439
		1440		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		1441		/// <param name="deploymentName"> The name of the deployment. </param>
		1442		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1443		public virtual async Task<DeploymentsDeleteAtTenantScopeOperation> StartDeleteAtTenantScopeAsync(string deployme
		1444		{
	0	1445		if (deploymentName == null)
		1446		{
	0	1447		throw new ArgumentNullException(nameof(deploymentName));
		1448		}
		1449
	0	1450		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDeleteAtTenantScope");
	0	1451		scope0.Start();
		1452		try
		1453		{
	0	1454		var originalResponse = await RestClient.DeleteAtTenantScopeAsync(deploymentName, cancellationToken).Conf
	0	1455		return new DeploymentsDeleteAtTenantScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateDelet
		1456		}
	0	1457		catch (Exception e)
		1458		{
	0	1459		scope0.Failed(e);
	0	1460		throw;
		1461		}
	0	1462		}
		1463
		1464		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		1465		/// <param name="deploymentName"> The name of the deployment. </param>
		1466		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1467		public virtual DeploymentsDeleteAtTenantScopeOperation StartDeleteAtTenantScope(string deploymentName, Cancellat
		1468		{
	0	1469		if (deploymentName == null)
		1470		{
	0	1471		throw new ArgumentNullException(nameof(deploymentName));
		1472		}
		1473
	0	1474		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDeleteAtTenantScope");
	0	1475		scope0.Start();
		1476		try
		1477		{
	0	1478		var originalResponse = RestClient.DeleteAtTenantScope(deploymentName, cancellationToken);
	0	1479		return new DeploymentsDeleteAtTenantScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateDelet
		1480		}
	0	1481		catch (Exception e)
		1482		{
	0	1483		scope0.Failed(e);
	0	1484		throw;
		1485		}
	0	1486		}
		1487
		1488		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		1489		/// <param name="deploymentName"> The name of the deployment. </param>
		1490		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		1491		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1492		public virtual async Task<DeploymentsCreateOrUpdateAtTenantScopeOperation> StartCreateOrUpdateAtTenantScopeAsync
		1493		{
	0	1494		if (deploymentName == null)
		1495		{
	0	1496		throw new ArgumentNullException(nameof(deploymentName));
		1497		}
	0	1498		if (parameters == null)
		1499		{
	0	1500		throw new ArgumentNullException(nameof(parameters));
		1501		}
		1502
	0	1503		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdateAtTenantScope");
	0	1504		scope0.Start();
		1505		try
		1506		{
	0	1507		var originalResponse = await RestClient.CreateOrUpdateAtTenantScopeAsync(deploymentName, parameters, can
	0	1508		return new DeploymentsCreateOrUpdateAtTenantScopeOperation(_clientDiagnostics, _pipeline, RestClient.Cre
		1509		}
	0	1510		catch (Exception e)
		1511		{
	0	1512		scope0.Failed(e);
	0	1513		throw;
		1514		}
	0	1515		}
		1516
		1517		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		1518		/// <param name="deploymentName"> The name of the deployment. </param>
		1519		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		1520		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1521		public virtual DeploymentsCreateOrUpdateAtTenantScopeOperation StartCreateOrUpdateAtTenantScope(string deploymen
		1522		{
	0	1523		if (deploymentName == null)
		1524		{
	0	1525		throw new ArgumentNullException(nameof(deploymentName));
		1526		}
	0	1527		if (parameters == null)
		1528		{
	0	1529		throw new ArgumentNullException(nameof(parameters));
		1530		}
		1531
	0	1532		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdateAtTenantScope");
	0	1533		scope0.Start();
		1534		try
		1535		{
	0	1536		var originalResponse = RestClient.CreateOrUpdateAtTenantScope(deploymentName, parameters, cancellationTo
	0	1537		return new DeploymentsCreateOrUpdateAtTenantScopeOperation(_clientDiagnostics, _pipeline, RestClient.Cre
		1538		}
	0	1539		catch (Exception e)
		1540		{
	0	1541		scope0.Failed(e);
	0	1542		throw;
		1543		}
	0	1544		}
		1545
		1546		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		1547		/// <param name="deploymentName"> The name of the deployment. </param>
		1548		/// <param name="parameters"> Parameters to validate. </param>
		1549		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1550		public virtual async Task<DeploymentsValidateAtTenantScopeOperation> StartValidateAtTenantScopeAsync(string depl
		1551		{
	0	1552		if (deploymentName == null)
		1553		{
	0	1554		throw new ArgumentNullException(nameof(deploymentName));
		1555		}
	0	1556		if (parameters == null)
		1557		{
	0	1558		throw new ArgumentNullException(nameof(parameters));
		1559		}
		1560
	0	1561		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidateAtTenantScope");
	0	1562		scope0.Start();
		1563		try
		1564		{
	0	1565		var originalResponse = await RestClient.ValidateAtTenantScopeAsync(deploymentName, parameters, cancellat
	0	1566		return new DeploymentsValidateAtTenantScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateVal
		1567		}
	0	1568		catch (Exception e)
		1569		{
	0	1570		scope0.Failed(e);
	0	1571		throw;
		1572		}
	0	1573		}
		1574
		1575		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		1576		/// <param name="deploymentName"> The name of the deployment. </param>
		1577		/// <param name="parameters"> Parameters to validate. </param>
		1578		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1579		public virtual DeploymentsValidateAtTenantScopeOperation StartValidateAtTenantScope(string deploymentName, Scope
		1580		{
	0	1581		if (deploymentName == null)
		1582		{
	0	1583		throw new ArgumentNullException(nameof(deploymentName));
		1584		}
	0	1585		if (parameters == null)
		1586		{
	0	1587		throw new ArgumentNullException(nameof(parameters));
		1588		}
		1589
	0	1590		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidateAtTenantScope");
	0	1591		scope0.Start();
		1592		try
		1593		{
	0	1594		var originalResponse = RestClient.ValidateAtTenantScope(deploymentName, parameters, cancellationToken);
	0	1595		return new DeploymentsValidateAtTenantScopeOperation(_clientDiagnostics, _pipeline, RestClient.CreateVal
		1596		}
	0	1597		catch (Exception e)
		1598		{
	0	1599		scope0.Failed(e);
	0	1600		throw;
		1601		}
	0	1602		}
		1603
		1604		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		1605		/// <param name="groupId"> The management group ID. </param>
		1606		/// <param name="deploymentName"> The name of the deployment. </param>
		1607		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1608		public virtual async Task<DeploymentsDeleteAtManagementGroupScopeOperation> StartDeleteAtManagementGroupScopeAsy
		1609		{
	0	1610		if (groupId == null)
		1611		{
	0	1612		throw new ArgumentNullException(nameof(groupId));
		1613		}
	0	1614		if (deploymentName == null)
		1615		{
	0	1616		throw new ArgumentNullException(nameof(deploymentName));
		1617		}
		1618
	0	1619		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDeleteAtManagementGroupScope")
	0	1620		scope0.Start();
		1621		try
		1622		{
	0	1623		var originalResponse = await RestClient.DeleteAtManagementGroupScopeAsync(groupId, deploymentName, cance
	0	1624		return new DeploymentsDeleteAtManagementGroupScopeOperation(_clientDiagnostics, _pipeline, RestClient.Cr
		1625		}
	0	1626		catch (Exception e)
		1627		{
	0	1628		scope0.Failed(e);
	0	1629		throw;
		1630		}
	0	1631		}
		1632
		1633		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		1634		/// <param name="groupId"> The management group ID. </param>
		1635		/// <param name="deploymentName"> The name of the deployment. </param>
		1636		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1637		public virtual DeploymentsDeleteAtManagementGroupScopeOperation StartDeleteAtManagementGroupScope(string groupId
		1638		{
	0	1639		if (groupId == null)
		1640		{
	0	1641		throw new ArgumentNullException(nameof(groupId));
		1642		}
	0	1643		if (deploymentName == null)
		1644		{
	0	1645		throw new ArgumentNullException(nameof(deploymentName));
		1646		}
		1647
	0	1648		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDeleteAtManagementGroupScope")
	0	1649		scope0.Start();
		1650		try
		1651		{
	0	1652		var originalResponse = RestClient.DeleteAtManagementGroupScope(groupId, deploymentName, cancellationToke
	0	1653		return new DeploymentsDeleteAtManagementGroupScopeOperation(_clientDiagnostics, _pipeline, RestClient.Cr
		1654		}
	0	1655		catch (Exception e)
		1656		{
	0	1657		scope0.Failed(e);
	0	1658		throw;
		1659		}
	0	1660		}
		1661
		1662		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		1663		/// <param name="groupId"> The management group ID. </param>
		1664		/// <param name="deploymentName"> The name of the deployment. </param>
		1665		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		1666		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1667		public virtual async Task<DeploymentsCreateOrUpdateAtManagementGroupScopeOperation> StartCreateOrUpdateAtManagem
		1668		{
	2	1669		if (groupId == null)
		1670		{
	0	1671		throw new ArgumentNullException(nameof(groupId));
		1672		}
	2	1673		if (deploymentName == null)
		1674		{
	0	1675		throw new ArgumentNullException(nameof(deploymentName));
		1676		}
	2	1677		if (parameters == null)
		1678		{
	0	1679		throw new ArgumentNullException(nameof(parameters));
		1680		}
		1681
	2	1682		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdateAtManagementGrou
	2	1683		scope0.Start();
		1684		try
		1685		{
	2	1686		var originalResponse = await RestClient.CreateOrUpdateAtManagementGroupScopeAsync(groupId, deploymentNam
	2	1687		return new DeploymentsCreateOrUpdateAtManagementGroupScopeOperation(_clientDiagnostics, _pipeline, RestC
		1688		}
	0	1689		catch (Exception e)
		1690		{
	0	1691		scope0.Failed(e);
	0	1692		throw;
		1693		}
	2	1694		}
		1695
		1696		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		1697		/// <param name="groupId"> The management group ID. </param>
		1698		/// <param name="deploymentName"> The name of the deployment. </param>
		1699		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		1700		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1701		public virtual DeploymentsCreateOrUpdateAtManagementGroupScopeOperation StartCreateOrUpdateAtManagementGroupScop
		1702		{
	2	1703		if (groupId == null)
		1704		{
	0	1705		throw new ArgumentNullException(nameof(groupId));
		1706		}
	2	1707		if (deploymentName == null)
		1708		{
	0	1709		throw new ArgumentNullException(nameof(deploymentName));
		1710		}
	2	1711		if (parameters == null)
		1712		{
	0	1713		throw new ArgumentNullException(nameof(parameters));
		1714		}
		1715
	2	1716		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdateAtManagementGrou
	2	1717		scope0.Start();
		1718		try
		1719		{
	2	1720		var originalResponse = RestClient.CreateOrUpdateAtManagementGroupScope(groupId, deploymentName, paramete
	2	1721		return new DeploymentsCreateOrUpdateAtManagementGroupScopeOperation(_clientDiagnostics, _pipeline, RestC
		1722		}
	0	1723		catch (Exception e)
		1724		{
	0	1725		scope0.Failed(e);
	0	1726		throw;
		1727		}
	2	1728		}
		1729
		1730		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		1731		/// <param name="groupId"> The management group ID. </param>
		1732		/// <param name="deploymentName"> The name of the deployment. </param>
		1733		/// <param name="parameters"> Parameters to validate. </param>
		1734		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1735		public virtual async Task<DeploymentsValidateAtManagementGroupScopeOperation> StartValidateAtManagementGroupScop
		1736		{
	2	1737		if (groupId == null)
		1738		{
	0	1739		throw new ArgumentNullException(nameof(groupId));
		1740		}
	2	1741		if (deploymentName == null)
		1742		{
	0	1743		throw new ArgumentNullException(nameof(deploymentName));
		1744		}
	2	1745		if (parameters == null)
		1746		{
	0	1747		throw new ArgumentNullException(nameof(parameters));
		1748		}
		1749
	2	1750		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidateAtManagementGroupScope
	2	1751		scope0.Start();
		1752		try
		1753		{
	2	1754		var originalResponse = await RestClient.ValidateAtManagementGroupScopeAsync(groupId, deploymentName, par
	2	1755		return new DeploymentsValidateAtManagementGroupScopeOperation(_clientDiagnostics, _pipeline, RestClient.
		1756		}
	0	1757		catch (Exception e)
		1758		{
	0	1759		scope0.Failed(e);
	0	1760		throw;
		1761		}
	2	1762		}
		1763
		1764		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		1765		/// <param name="groupId"> The management group ID. </param>
		1766		/// <param name="deploymentName"> The name of the deployment. </param>
		1767		/// <param name="parameters"> Parameters to validate. </param>
		1768		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1769		public virtual DeploymentsValidateAtManagementGroupScopeOperation StartValidateAtManagementGroupScope(string gro
		1770		{
	2	1771		if (groupId == null)
		1772		{
	0	1773		throw new ArgumentNullException(nameof(groupId));
		1774		}
	2	1775		if (deploymentName == null)
		1776		{
	0	1777		throw new ArgumentNullException(nameof(deploymentName));
		1778		}
	2	1779		if (parameters == null)
		1780		{
	0	1781		throw new ArgumentNullException(nameof(parameters));
		1782		}
		1783
	2	1784		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidateAtManagementGroupScope
	2	1785		scope0.Start();
		1786		try
		1787		{
	2	1788		var originalResponse = RestClient.ValidateAtManagementGroupScope(groupId, deploymentName, parameters, ca
	2	1789		return new DeploymentsValidateAtManagementGroupScopeOperation(_clientDiagnostics, _pipeline, RestClient.
		1790		}
	0	1791		catch (Exception e)
		1792		{
	0	1793		scope0.Failed(e);
	0	1794		throw;
		1795		}
	2	1796		}
		1797
		1798		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		1799		/// <param name="deploymentName"> The name of the deployment. </param>
		1800		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1801		public virtual async Task<DeploymentsDeleteAtSubscriptionScopeOperation> StartDeleteAtSubscriptionScopeAsync(str
		1802		{
	0	1803		if (deploymentName == null)
		1804		{
	0	1805		throw new ArgumentNullException(nameof(deploymentName));
		1806		}
		1807
	0	1808		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDeleteAtSubscriptionScope");
	0	1809		scope0.Start();
		1810		try
		1811		{
	0	1812		var originalResponse = await RestClient.DeleteAtSubscriptionScopeAsync(deploymentName, cancellationToken
	0	1813		return new DeploymentsDeleteAtSubscriptionScopeOperation(_clientDiagnostics, _pipeline, RestClient.Creat
		1814		}
	0	1815		catch (Exception e)
		1816		{
	0	1817		scope0.Failed(e);
	0	1818		throw;
		1819		}
	0	1820		}
		1821
		1822		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		1823		/// <param name="deploymentName"> The name of the deployment. </param>
		1824		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1825		public virtual DeploymentsDeleteAtSubscriptionScopeOperation StartDeleteAtSubscriptionScope(string deploymentNam
		1826		{
	0	1827		if (deploymentName == null)
		1828		{
	0	1829		throw new ArgumentNullException(nameof(deploymentName));
		1830		}
		1831
	0	1832		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDeleteAtSubscriptionScope");
	0	1833		scope0.Start();
		1834		try
		1835		{
	0	1836		var originalResponse = RestClient.DeleteAtSubscriptionScope(deploymentName, cancellationToken);
	0	1837		return new DeploymentsDeleteAtSubscriptionScopeOperation(_clientDiagnostics, _pipeline, RestClient.Creat
		1838		}
	0	1839		catch (Exception e)
		1840		{
	0	1841		scope0.Failed(e);
	0	1842		throw;
		1843		}
	0	1844		}
		1845
		1846		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		1847		/// <param name="deploymentName"> The name of the deployment. </param>
		1848		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		1849		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1850		public virtual async Task<DeploymentsCreateOrUpdateAtSubscriptionScopeOperation> StartCreateOrUpdateAtSubscripti
		1851		{
	4	1852		if (deploymentName == null)
		1853		{
	0	1854		throw new ArgumentNullException(nameof(deploymentName));
		1855		}
	4	1856		if (parameters == null)
		1857		{
	0	1858		throw new ArgumentNullException(nameof(parameters));
		1859		}
		1860
	4	1861		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdateAtSubscriptionSc
	4	1862		scope0.Start();
		1863		try
		1864		{
	4	1865		var originalResponse = await RestClient.CreateOrUpdateAtSubscriptionScopeAsync(deploymentName, parameter
	4	1866		return new DeploymentsCreateOrUpdateAtSubscriptionScopeOperation(_clientDiagnostics, _pipeline, RestClie
		1867		}
	0	1868		catch (Exception e)
		1869		{
	0	1870		scope0.Failed(e);
	0	1871		throw;
		1872		}
	4	1873		}
		1874
		1875		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		1876		/// <param name="deploymentName"> The name of the deployment. </param>
		1877		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		1878		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1879		public virtual DeploymentsCreateOrUpdateAtSubscriptionScopeOperation StartCreateOrUpdateAtSubscriptionScope(stri
		1880		{
	4	1881		if (deploymentName == null)
		1882		{
	0	1883		throw new ArgumentNullException(nameof(deploymentName));
		1884		}
	4	1885		if (parameters == null)
		1886		{
	0	1887		throw new ArgumentNullException(nameof(parameters));
		1888		}
		1889
	4	1890		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdateAtSubscriptionSc
	4	1891		scope0.Start();
		1892		try
		1893		{
	4	1894		var originalResponse = RestClient.CreateOrUpdateAtSubscriptionScope(deploymentName, parameters, cancella
	4	1895		return new DeploymentsCreateOrUpdateAtSubscriptionScopeOperation(_clientDiagnostics, _pipeline, RestClie
		1896		}
	0	1897		catch (Exception e)
		1898		{
	0	1899		scope0.Failed(e);
	0	1900		throw;
		1901		}
	4	1902		}
		1903
		1904		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		1905		/// <param name="deploymentName"> The name of the deployment. </param>
		1906		/// <param name="parameters"> Parameters to validate. </param>
		1907		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1908		public virtual async Task<DeploymentsValidateAtSubscriptionScopeOperation> StartValidateAtSubscriptionScopeAsync
		1909		{
	2	1910		if (deploymentName == null)
		1911		{
	0	1912		throw new ArgumentNullException(nameof(deploymentName));
		1913		}
	2	1914		if (parameters == null)
		1915		{
	0	1916		throw new ArgumentNullException(nameof(parameters));
		1917		}
		1918
	2	1919		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidateAtSubscriptionScope");
	2	1920		scope0.Start();
		1921		try
		1922		{
	2	1923		var originalResponse = await RestClient.ValidateAtSubscriptionScopeAsync(deploymentName, parameters, can
	2	1924		return new DeploymentsValidateAtSubscriptionScopeOperation(_clientDiagnostics, _pipeline, RestClient.Cre
		1925		}
	0	1926		catch (Exception e)
		1927		{
	0	1928		scope0.Failed(e);
	0	1929		throw;
		1930		}
	2	1931		}
		1932
		1933		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		1934		/// <param name="deploymentName"> The name of the deployment. </param>
		1935		/// <param name="parameters"> Parameters to validate. </param>
		1936		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1937		public virtual DeploymentsValidateAtSubscriptionScopeOperation StartValidateAtSubscriptionScope(string deploymen
		1938		{
	2	1939		if (deploymentName == null)
		1940		{
	0	1941		throw new ArgumentNullException(nameof(deploymentName));
		1942		}
	2	1943		if (parameters == null)
		1944		{
	0	1945		throw new ArgumentNullException(nameof(parameters));
		1946		}
		1947
	2	1948		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidateAtSubscriptionScope");
	2	1949		scope0.Start();
		1950		try
		1951		{
	2	1952		var originalResponse = RestClient.ValidateAtSubscriptionScope(deploymentName, parameters, cancellationTo
	2	1953		return new DeploymentsValidateAtSubscriptionScopeOperation(_clientDiagnostics, _pipeline, RestClient.Cre
		1954		}
	0	1955		catch (Exception e)
		1956		{
	0	1957		scope0.Failed(e);
	0	1958		throw;
		1959		}
	2	1960		}
		1961
		1962		/// <summary> Returns changes that will be made by the deployment if executed at the scope of the subscription.
		1963		/// <param name="deploymentName"> The name of the deployment. </param>
		1964		/// <param name="parameters"> Parameters to What If. </param>
		1965		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1966		public virtual async Task<DeploymentsWhatIfAtSubscriptionScopeOperation> StartWhatIfAtSubscriptionScopeAsync(str
		1967		{
	18	1968		if (deploymentName == null)
		1969		{
	0	1970		throw new ArgumentNullException(nameof(deploymentName));
		1971		}
	18	1972		if (parameters == null)
		1973		{
	0	1974		throw new ArgumentNullException(nameof(parameters));
		1975		}
		1976
	18	1977		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartWhatIfAtSubscriptionScope");
	18	1978		scope0.Start();
		1979		try
		1980		{
	18	1981		var originalResponse = await RestClient.WhatIfAtSubscriptionScopeAsync(deploymentName, parameters, cance
	18	1982		return new DeploymentsWhatIfAtSubscriptionScopeOperation(_clientDiagnostics, _pipeline, RestClient.Creat
		1983		}
	0	1984		catch (Exception e)
		1985		{
	0	1986		scope0.Failed(e);
	0	1987		throw;
		1988		}
	18	1989		}
		1990
		1991		/// <summary> Returns changes that will be made by the deployment if executed at the scope of the subscription.
		1992		/// <param name="deploymentName"> The name of the deployment. </param>
		1993		/// <param name="parameters"> Parameters to What If. </param>
		1994		/// <param name="cancellationToken"> The cancellation token to use. </param>
		1995		public virtual DeploymentsWhatIfAtSubscriptionScopeOperation StartWhatIfAtSubscriptionScope(string deploymentNam
		1996		{
	18	1997		if (deploymentName == null)
		1998		{
	0	1999		throw new ArgumentNullException(nameof(deploymentName));
		2000		}
	18	2001		if (parameters == null)
		2002		{
	0	2003		throw new ArgumentNullException(nameof(parameters));
		2004		}
		2005
	18	2006		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartWhatIfAtSubscriptionScope");
	18	2007		scope0.Start();
		2008		try
		2009		{
	18	2010		var originalResponse = RestClient.WhatIfAtSubscriptionScope(deploymentName, parameters, cancellationToke
	18	2011		return new DeploymentsWhatIfAtSubscriptionScopeOperation(_clientDiagnostics, _pipeline, RestClient.Creat
		2012		}
	0	2013		catch (Exception e)
		2014		{
	0	2015		scope0.Failed(e);
	0	2016		throw;
		2017		}
	18	2018		}
		2019
		2020		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		2021		/// <param name="resourceGroupName"> The name of the resource group with the deployment to delete. The name is c
		2022		/// <param name="deploymentName"> The name of the deployment. </param>
		2023		/// <param name="cancellationToken"> The cancellation token to use. </param>
		2024		public virtual async Task<DeploymentsDeleteOperation> StartDeleteAsync(string resourceGroupName, string deployme
		2025		{
	0	2026		if (resourceGroupName == null)
		2027		{
	0	2028		throw new ArgumentNullException(nameof(resourceGroupName));
		2029		}
	0	2030		if (deploymentName == null)
		2031		{
	0	2032		throw new ArgumentNullException(nameof(deploymentName));
		2033		}
		2034
	0	2035		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDelete");
	0	2036		scope0.Start();
		2037		try
		2038		{
	0	2039		var originalResponse = await RestClient.DeleteAsync(resourceGroupName, deploymentName, cancellationToken
	0	2040		return new DeploymentsDeleteOperation(_clientDiagnostics, _pipeline, RestClient.CreateDeleteRequest(reso
		2041		}
	0	2042		catch (Exception e)
		2043		{
	0	2044		scope0.Failed(e);
	0	2045		throw;
		2046		}
	0	2047		}
		2048
		2049		/// <summary> A template deployment that is currently running cannot be deleted. Deleting a template deployment
		2050		/// <param name="resourceGroupName"> The name of the resource group with the deployment to delete. The name is c
		2051		/// <param name="deploymentName"> The name of the deployment. </param>
		2052		/// <param name="cancellationToken"> The cancellation token to use. </param>
		2053		public virtual DeploymentsDeleteOperation StartDelete(string resourceGroupName, string deploymentName, Cancellat
		2054		{
	0	2055		if (resourceGroupName == null)
		2056		{
	0	2057		throw new ArgumentNullException(nameof(resourceGroupName));
		2058		}
	0	2059		if (deploymentName == null)
		2060		{
	0	2061		throw new ArgumentNullException(nameof(deploymentName));
		2062		}
		2063
	0	2064		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartDelete");
	0	2065		scope0.Start();
		2066		try
		2067		{
	0	2068		var originalResponse = RestClient.Delete(resourceGroupName, deploymentName, cancellationToken);
	0	2069		return new DeploymentsDeleteOperation(_clientDiagnostics, _pipeline, RestClient.CreateDeleteRequest(reso
		2070		}
	0	2071		catch (Exception e)
		2072		{
	0	2073		scope0.Failed(e);
	0	2074		throw;
		2075		}
	0	2076		}
		2077
		2078		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		2079		/// <param name="resourceGroupName"> The name of the resource group to deploy the resources to. The name is case
		2080		/// <param name="deploymentName"> The name of the deployment. </param>
		2081		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		2082		/// <param name="cancellationToken"> The cancellation token to use. </param>
		2083		public virtual async Task<DeploymentsCreateOrUpdateOperation> StartCreateOrUpdateAsync(string resourceGroupName,
		2084		{
	16	2085		if (resourceGroupName == null)
		2086		{
	0	2087		throw new ArgumentNullException(nameof(resourceGroupName));
		2088		}
	16	2089		if (deploymentName == null)
		2090		{
	0	2091		throw new ArgumentNullException(nameof(deploymentName));
		2092		}
	16	2093		if (parameters == null)
		2094		{
	0	2095		throw new ArgumentNullException(nameof(parameters));
		2096		}
		2097
	16	2098		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdate");
	16	2099		scope0.Start();
		2100		try
		2101		{
	16	2102		var originalResponse = await RestClient.CreateOrUpdateAsync(resourceGroupName, deploymentName, parameter
	16	2103		return new DeploymentsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUp
		2104		}
	0	2105		catch (Exception e)
		2106		{
	0	2107		scope0.Failed(e);
	0	2108		throw;
		2109		}
	16	2110		}
		2111
		2112		/// <summary> You can provide the template and parameters directly in the request or link to JSON files. </summa
		2113		/// <param name="resourceGroupName"> The name of the resource group to deploy the resources to. The name is case
		2114		/// <param name="deploymentName"> The name of the deployment. </param>
		2115		/// <param name="parameters"> Additional parameters supplied to the operation. </param>
		2116		/// <param name="cancellationToken"> The cancellation token to use. </param>
		2117		public virtual DeploymentsCreateOrUpdateOperation StartCreateOrUpdate(string resourceGroupName, string deploymen
		2118		{
	16	2119		if (resourceGroupName == null)
		2120		{
	0	2121		throw new ArgumentNullException(nameof(resourceGroupName));
		2122		}
	16	2123		if (deploymentName == null)
		2124		{
	0	2125		throw new ArgumentNullException(nameof(deploymentName));
		2126		}
	16	2127		if (parameters == null)
		2128		{
	0	2129		throw new ArgumentNullException(nameof(parameters));
		2130		}
		2131
	16	2132		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartCreateOrUpdate");
	16	2133		scope0.Start();
		2134		try
		2135		{
	16	2136		var originalResponse = RestClient.CreateOrUpdate(resourceGroupName, deploymentName, parameters, cancella
	16	2137		return new DeploymentsCreateOrUpdateOperation(_clientDiagnostics, _pipeline, RestClient.CreateCreateOrUp
		2138		}
	0	2139		catch (Exception e)
		2140		{
	0	2141		scope0.Failed(e);
	0	2142		throw;
		2143		}
	16	2144		}
		2145
		2146		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		2147		/// <param name="resourceGroupName"> The name of the resource group the template will be deployed to. The name i
		2148		/// <param name="deploymentName"> The name of the deployment. </param>
		2149		/// <param name="parameters"> Parameters to validate. </param>
		2150		/// <param name="cancellationToken"> The cancellation token to use. </param>
		2151		public virtual async Task<DeploymentsValidateOperation> StartValidateAsync(string resourceGroupName, string depl
		2152		{
	12	2153		if (resourceGroupName == null)
		2154		{
	0	2155		throw new ArgumentNullException(nameof(resourceGroupName));
		2156		}
	12	2157		if (deploymentName == null)
		2158		{
	0	2159		throw new ArgumentNullException(nameof(deploymentName));
		2160		}
	12	2161		if (parameters == null)
		2162		{
	0	2163		throw new ArgumentNullException(nameof(parameters));
		2164		}
		2165
	12	2166		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidate");
	12	2167		scope0.Start();
		2168		try
		2169		{
	12	2170		var originalResponse = await RestClient.ValidateAsync(resourceGroupName, deploymentName, parameters, can
	12	2171		return new DeploymentsValidateOperation(_clientDiagnostics, _pipeline, RestClient.CreateValidateRequest(
		2172		}
	0	2173		catch (Exception e)
		2174		{
	0	2175		scope0.Failed(e);
	0	2176		throw;
		2177		}
	12	2178		}
		2179
		2180		/// <summary> Validates whether the specified template is syntactically correct and will be accepted by Azure Re
		2181		/// <param name="resourceGroupName"> The name of the resource group the template will be deployed to. The name i
		2182		/// <param name="deploymentName"> The name of the deployment. </param>
		2183		/// <param name="parameters"> Parameters to validate. </param>
		2184		/// <param name="cancellationToken"> The cancellation token to use. </param>
		2185		public virtual DeploymentsValidateOperation StartValidate(string resourceGroupName, string deploymentName, Deplo
		2186		{
	12	2187		if (resourceGroupName == null)
		2188		{
	0	2189		throw new ArgumentNullException(nameof(resourceGroupName));
		2190		}
	12	2191		if (deploymentName == null)
		2192		{
	0	2193		throw new ArgumentNullException(nameof(deploymentName));
		2194		}
	12	2195		if (parameters == null)
		2196		{
	0	2197		throw new ArgumentNullException(nameof(parameters));
		2198		}
		2199
	12	2200		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartValidate");
	12	2201		scope0.Start();
		2202		try
		2203		{
	12	2204		var originalResponse = RestClient.Validate(resourceGroupName, deploymentName, parameters, cancellationTo
	12	2205		return new DeploymentsValidateOperation(_clientDiagnostics, _pipeline, RestClient.CreateValidateRequest(
		2206		}
	0	2207		catch (Exception e)
		2208		{
	0	2209		scope0.Failed(e);
	0	2210		throw;
		2211		}
	12	2212		}
		2213
		2214		/// <summary> Returns changes that will be made by the deployment if executed at the scope of the resource group
		2215		/// <param name="resourceGroupName"> The name of the resource group the template will be deployed to. The name i
		2216		/// <param name="deploymentName"> The name of the deployment. </param>
		2217		/// <param name="parameters"> Parameters to validate. </param>
		2218		/// <param name="cancellationToken"> The cancellation token to use. </param>
		2219		public virtual async Task<DeploymentsWhatIfOperation> StartWhatIfAsync(string resourceGroupName, string deployme
		2220		{
	20	2221		if (resourceGroupName == null)
		2222		{
	0	2223		throw new ArgumentNullException(nameof(resourceGroupName));
		2224		}
	20	2225		if (deploymentName == null)
		2226		{
	0	2227		throw new ArgumentNullException(nameof(deploymentName));
		2228		}
	20	2229		if (parameters == null)
		2230		{
	0	2231		throw new ArgumentNullException(nameof(parameters));
		2232		}
		2233
	20	2234		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartWhatIf");
	20	2235		scope0.Start();
		2236		try
		2237		{
	20	2238		var originalResponse = await RestClient.WhatIfAsync(resourceGroupName, deploymentName, parameters, cance
	20	2239		return new DeploymentsWhatIfOperation(_clientDiagnostics, _pipeline, RestClient.CreateWhatIfRequest(reso
		2240		}
	0	2241		catch (Exception e)
		2242		{
	0	2243		scope0.Failed(e);
	0	2244		throw;
		2245		}
	20	2246		}
		2247
		2248		/// <summary> Returns changes that will be made by the deployment if executed at the scope of the resource group
		2249		/// <param name="resourceGroupName"> The name of the resource group the template will be deployed to. The name i
		2250		/// <param name="deploymentName"> The name of the deployment. </param>
		2251		/// <param name="parameters"> Parameters to validate. </param>
		2252		/// <param name="cancellationToken"> The cancellation token to use. </param>
		2253		public virtual DeploymentsWhatIfOperation StartWhatIf(string resourceGroupName, string deploymentName, Deploymen
		2254		{
	20	2255		if (resourceGroupName == null)
		2256		{
	0	2257		throw new ArgumentNullException(nameof(resourceGroupName));
		2258		}
	20	2259		if (deploymentName == null)
		2260		{
	0	2261		throw new ArgumentNullException(nameof(deploymentName));
		2262		}
	20	2263		if (parameters == null)
		2264		{
	0	2265		throw new ArgumentNullException(nameof(parameters));
		2266		}
		2267
	20	2268		using var scope0 = _clientDiagnostics.CreateScope("DeploymentsOperations.StartWhatIf");
	20	2269		scope0.Start();
		2270		try
		2271		{
	20	2272		var originalResponse = RestClient.WhatIf(resourceGroupName, deploymentName, parameters, cancellationToke
	20	2273		return new DeploymentsWhatIfOperation(_clientDiagnostics, _pipeline, RestClient.CreateWhatIfRequest(reso
		2274		}
	0	2275		catch (Exception e)
		2276		{
	0	2277		scope0.Failed(e);
	0	2278		throw;
		2279		}
	20	2280		}
		2281		}
		2282		}