< Summary

Class:	Azure.DigitalTwins.Core.DigitalTwinsRestClient
Assembly:	Azure.DigitalTwins.Core
File(s):	C:\Git\azure-sdk-for-net\sdk\digitaltwins\Azure.DigitalTwins.Core\src\Customized\DigitalTwinsRestClient.cs C:\Git\azure-sdk-for-net\sdk\digitaltwins\Azure.DigitalTwins.Core\src\Generated\DigitalTwinsRestClient.cs
Covered lines:	588
Uncovered lines:	430
Coverable lines:	1018
Total lines:	1741
Line coverage:	57.7% (588 of 1018)
Covered branches:	138
Total branches:	340
Branch coverage:	40.5% (138 of 340)

Metrics

Method	Cyclomatic complexity	Line coverage	Branch coverage
CreateAddRequest(...)	-	100%	100%
.ctor(...)	-	90.91%	50%
AddAsync()	-	93.94%	50%
CreateGetByIdRequest(...)	-	100%	50%
CreateDeleteRequest(...)	-	84.62%	50%
Add(...)	-	69.57%	50%
DeleteAsync()	-	91.67%	50%
GetByIdAsync()	-	69.57%	50%
Delete(...)	-	80%	66.67%
CreateUpdateRequest(...)	-	45%	16.67%
GetById(...)	-	81.48%	50%
CreateGetRelationshipByIdRequest(...)	-	100%	100%
CreateAddRelationshipRequest(...)	-	35%	33.33%
UpdateAsync()	-	63.64%	41.67%
CreateDeleteRelationshipRequest(...)	-	81.25%	50%
Update(...)	-	60.87%	50%
DeleteRelationshipAsync()	-	71.43%	50%
GetRelationshipByIdAsync()	-	70.37%	58.33%
DeleteRelationship(...)	-	80%	60%
CreateUpdateRelationshipRequest(...)	-	46.15%	40%
GetRelationshipById(...)	-	74.07%	60%
CreateListRelationshipsRequest(...)	-	100%	100%
AddRelationshipAsync()	-	70.83%	41.67%
ListRelationshipsAsync()	-	80%	37.5%
AddRelationship(...)	-	80.77%	41.67%
ListRelationships(...)	-	85.71%	37.5%
CreateListIncomingRelationshipsRequest(...)	-	100%	50%
UpdateRelationshipAsync()	-	73.68%	50%
ListIncomingRelationshipsAsync()	-	76.47%	50%
UpdateRelationship(...)	-	78.95%	50%
ListIncomingRelationships(...)	-	73.33%	50%
GetComponentAsync()	-	46.67%	37.5%
CreateSendTelemetryRequest(...)	-	31.58%	25%
CreateSendComponentTelemetryRequest(...)	-	33.33%	37.5%
GetComponent(...)	-	62.5%	37.5%
CreateGetComponentRequest(...)	-	100%	100%
UpdateComponentAsync()	-	29.03%	28.57%
CreateUpdateComponentRequest(...)	-	29.17%	25%
CreateListRelationshipsNextPageRequest(...)	-	25%	50%
UpdateComponent(...)	-	37.5%	28.57%
ListRelationshipsNextPageAsync()	-	17.65%	12.5%
SendTelemetryAsync()	-	52.63%	28.57%
ListRelationshipsNextPage(...)	-	35.29%	25%
SendTelemetry(...)	-	41.67%	40%
CreateListIncomingRelationshipsNextPageRequest(...)	-	25%	100%
ListIncomingRelationshipsNextPageAsync()	-	43.75%	33.33%
SendComponentTelemetryAsync()	-	47.83%	35.71%
ListIncomingRelationshipsNextPage(...)	-	37.5%	28.57%
SendComponentTelemetry(...)	-	47.83%	41.67%
CreateUpdateRequest(...)	-	100%	100%
CreateAddRelationshipRequest(...)	-	100%	100%
CreateUpdateRelationshipRequest(...)	-	94.12%	75%
CreateUpdateComponentRequest(...)	-	94.12%	75%
CreateSendTelemetryRequest(...)	-	100%	100%
CreateSendComponentTelemetryRequest(...)	-	100%	100%
AddAsync(...)	-	0%	100%
Add(...)	-	0%	100%
UpdateAsync(...)	-	0%	100%
Update(...)	-	0%	100%
AddRelationshipAsync(...)	-	0%	100%
AddRelationship(...)	-	0%	100%
UpdateRelationshipAsync(...)	-	0%	100%
UpdateRelationship(...)	-	0%	100%
UpdateComponentAsync(...)	-	0%	100%
UpdateComponent(...)	-	0%	100%
SendTelemetryAsync(...)	-	0%	100%
SendTelemetry(...)	-	0%	100%
SendComponentTelemetryAsync(...)	-	0%	100%
SendComponentTelemetry(...)	-	0%	100%
CreateAddRequest(...)	-	0%	100%
.ctor(...)	-	88.89%	50%
CreateGetByIdRequest(...)	-	100%	100%
CreateDeleteRequest(...)	-	91.67%	50%
DeleteAsync()	-	75%	50%
Delete(...)	-	75%	50%
CreateUpdateRequest(...)	-	0%	0%
CreateGetRelationshipByIdRequest(...)	-	100%	100%
CreateAddRelationshipRequest(...)	-	0%	0%
CreateDeleteRelationshipRequest(...)	-	92.86%	50%
DeleteRelationshipAsync()	-	70%	50%
DeleteRelationship(...)	-	70%	50%
CreateUpdateRelationshipRequest(...)	-	0%	0%
CreateListRelationshipsRequest(...)	-	100%	100%
ListRelationshipsAsync()	-	80%	50%
ListRelationships(...)	-	80%	50%
CreateListIncomingRelationshipsRequest(...)	-	100%	100%
ListIncomingRelationshipsAsync()	-	80%	50%
ListIncomingRelationships(...)	-	80%	50%
CreateSendTelemetryRequest(...)	-	0%	0%
CreateSendComponentTelemetryRequest(...)	-	0%	0%
CreateGetComponentRequest(...)	-	100%	100%
CreateUpdateComponentRequest(...)	-	0%	0%
CreateListRelationshipsNextPageRequest(...)	-	0%	100%
ListRelationshipsNextPageAsync()	-	0%	0%
ListRelationshipsNextPage(...)	-	0%	0%
CreateListIncomingRelationshipsNextPageRequest(...)	-	0%	100%
ListIncomingRelationshipsNextPageAsync()	-	0%	0%
ListIncomingRelationshipsNextPage(...)	-	0%	0%

File(s)

C:\Git\azure-sdk-for-net\sdk\digitaltwins\Azure.DigitalTwins.Core\src\Customized\DigitalTwinsRestClient.cs

	#	Line		Line coverage
		1		// Copyright (c) Microsoft Corporation. All rights reserved.
		2		// Licensed under the MIT License.
		3
		4		using System;
		5		using System.Collections.Generic;
		6		using System.Text.Json;
		7		using System.Threading;
		8		using System.Threading.Tasks;
		9		using Azure.Core;
		10		using Azure.Core.Pipeline;
		11
		12		namespace Azure.DigitalTwins.Core
		13		{
		14		// Declaring this class here will make it so that we can force its methods to use strings instead of
		15		// objects for json inputs/return values
		16		internal partial class DigitalTwinsRestClient
		17		{
		18		private const string IfMatchHeaderKey = "If-Match";
		19
		20		internal HttpMessage CreateAddRequest(string id, string twin)
		21		{
	28	22		HttpMessage message = _pipeline.CreateMessage();
	28	23		Request request = message.Request;
	28	24		request.Method = RequestMethod.Put;
	28	25		var uri = new RawRequestUriBuilder();
	28	26		uri.Reset(endpoint);
	28	27		uri.AppendPath("/digitaltwins/", false);
	28	28		uri.AppendPath(id, true);
	28	29		uri.AppendQuery("api-version", apiVersion, true);
	28	30		request.Uri = uri;
	28	31		request.Headers.Add("Content-Type", "application/json; charset=utf-8");
	58	32		request.Content = new StringRequestContent(twin);
	28	33		return message;
	30	34		}
	30	35
		36		internal async Task<Response<string>> AddAsync(string id, string twin, CancellationToken cancellationToken = def
	0	37		{
	14	38		if (id == null)
		39		{
	30	40		throw new ArgumentNullException(nameof(id));
	30	41		}
	44	42		if (twin == null)
	30	43		{
	30	44		throw new ArgumentNullException(nameof(twin));
		45		}
		46
	14	47		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.Add");
	41	48		scope.Start();
	27	49		try
	27	50		{
	41	51		using HttpMessage message = CreateAddRequest(id, twin);
	41	52		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	41	53		switch (message.Response.Status)
	27	54		{
	27	55		case 200:
	27	56		case 202:
	27	57		{
		58		string value = default;
	14	59		using JsonDocument document = await JsonDocument.ParseAsync(message.Response.ContentStream,
	14	60		value = document.RootElement.GetRawText();
	14	61		return Response.FromValue(value, message.Response);
	12	62		}
	12	63		case 201:
	12	64		return Response.FromValue<string>(null, message.Response);
	12	65
	12	66		default:
	12	67		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
	12	68		}
	12	69		}
	12	70		catch (Exception e)
	12	71		{
	0	72		scope.Failed(e);
	0	73		throw;
		74		}
	26	75		}
		76
		77		internal Response<string> Add(string id, string twin, CancellationToken cancellationToken = default)
		78		{
	14	79		if (id == null)
		80		{
	0	81		throw new ArgumentNullException(nameof(id));
		82		}
	14	83		if (twin == null)
		84		{
	0	85		throw new ArgumentNullException(nameof(twin));
		86		}
		87
	14	88		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.Add");
	14	89		scope.Start();
		90		try
	6	91		{
	14	92		using HttpMessage message = CreateAddRequest(id, twin);
	14	93		_pipeline.Send(message, cancellationToken);
	14	94		switch (message.Response.Status)
		95		{
	6	96		case 200:
	6	97		case 202:
	6	98		{
		99		string value = default;
	14	100		using var document = JsonDocument.Parse(message.Response.ContentStream);
	20	101		value = document.RootElement.GetRawText();
	14	102		return Response.FromValue(value, message.Response);
	0	103		}
		104		case 201:
	6	105		return Response.FromValue<string>(null, message.Response);
		106
		107		default:
	0	108		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		109		}
		110		}
	0	111		catch (Exception e)
		112		{
	0	113		scope.Failed(e);
	0	114		throw;
		115		}
	14	116		}
		117
		118		internal async Task<Response<string>> GetByIdAsync(string id, CancellationToken cancellationToken = default)
		119		{
	34	120		if (id == null)
		121		{
	0	122		throw new ArgumentNullException(nameof(id));
		123		}
		124
	34	125		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.GetById");
	34	126		scope.Start();
	6	127		try
		128		{
	28	129		using HttpMessage message = CreateGetByIdRequest(id);
	34	130		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	28	131		switch (message.Response.Status)
	0	132		{
		133		case 200:
	6	134		{
		135		string value = default;
	6	136		using JsonDocument document = await JsonDocument.ParseAsync(message.Response.ContentStream,
	6	137		value = document.RootElement.GetRawText();
	6	138		return Response.FromValue(value, message.Response);
	0	139		}
	0	140		default:
	22	141		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
	0	142		}
	0	143		}
	22	144		catch (Exception e)
	0	145		{
	22	146		scope.Failed(e);
	22	147		throw;
		148		}
	6	149		}
		150
	0	151		internal Response<string> GetById(string id, CancellationToken cancellationToken = default)
	0	152		{
	26	153		if (id == null)
	0	154		{
	0	155		throw new ArgumentNullException(nameof(id));
	0	156		}
		157
	26	158		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.GetById");
	26	159		scope.Start();
	0	160		try
		161		{
	26	162		using HttpMessage message = CreateGetByIdRequest(id);
	26	163		_pipeline.Send(message, cancellationToken);
	26	164		switch (message.Response.Status)
	10	165		{
	10	166		case 200:
	10	167		{
	10	168		string value = default;
	14	169		using var document = JsonDocument.Parse(message.Response.ContentStream);
	14	170		value = document.RootElement.GetRawText();
	14	171		return Response.FromValue(value, message.Response);
	10	172		}
	10	173		default:
	32	174		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
	10	175		}
	10	176		}
	22	177		catch (Exception e)
		178		{
	22	179		scope.Failed(e);
	22	180		throw;
	0	181		}
	4	182		}
	0	183
	0	184		internal async Task<Response<string>> UpdateAsync(string id, string patchDocument, string ifMatch = null, Cancel
	0	185		{
	2	186		if (id == null)
	0	187		{
	0	188		throw new ArgumentNullException(nameof(id));
	0	189		}
	2	190		if (patchDocument == null)
	0	191		{
	0	192		throw new ArgumentNullException(nameof(patchDocument));
	0	193		}
	0	194
	2	195		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.Update");
	2	196		scope.Start();
	0	197		try
	0	198		{
	2	199		using HttpMessage message = CreateUpdateRequest(id, patchDocument, ifMatch);
	2	200		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	2	201		switch (message.Response.Status)
		202		{
		203		case 202:
		204		{
	8	205		string value = default;
	8	206		using JsonDocument document = await JsonDocument.ParseAsync(message.Response.ContentStream,
	8	207		value = document.RootElement.GetRawText();
	8	208		return Response.FromValue(value, message.Response);
	8	209		}
	8	210		case 204:
	10	211		return Response.FromValue<string>(null, message.Response);
	8	212
	8	213		default:
	8	214		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
	8	215		}
	8	216		}
	0	217		catch (Exception e)
	0	218		{
	0	219		scope.Failed(e);
	8	220		throw;
		221		}
	2	222		}
		223
		224		internal Response<string> Update(string id, string patchDocument, string ifMatch = null, CancellationToken cance
		225		{
	2	226		if (id == null)
		227		{
	0	228		throw new ArgumentNullException(nameof(id));
		229		}
	2	230		if (patchDocument == null)
		231		{
	0	232		throw new ArgumentNullException(nameof(patchDocument));
		233		}
		234
	2	235		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.Update");
	6	236		scope.Start();
		237		try
	0	238		{
	2	239		using HttpMessage message = CreateUpdateRequest(id, patchDocument, ifMatch);
	6	240		_pipeline.Send(message, cancellationToken);
	2	241		switch (message.Response.Status)
	0	242		{
		243		case 202:
		244		{
	4	245		string value = default;
	4	246		using var document = JsonDocument.Parse(message.Response.ContentStream);
	4	247		value = document.RootElement.GetRawText();
	0	248		return Response.FromValue(value, message.Response);
		249		}
	4	250		case 204:
	2	251		return Response.FromValue<string>(null, message.Response);
	0	252
		253		default:
	4	254		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		255		}
		256		}
	0	257		catch (Exception e)
		258		{
	0	259		scope.Failed(e);
	0	260		throw;
		261		}
	2	262		}
		263
		264		internal async Task<Response<string>> GetRelationshipByIdAsync(string id, string relationshipId, CancellationTok
		265		{
	10	266		if (id == null)
		267		{
	0	268		throw new ArgumentNullException(nameof(id));
	4	269		}
	10	270		if (relationshipId == null)
	0	271		{
	0	272		throw new ArgumentNullException(nameof(relationshipId));
	4	273		}
		274
	10	275		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.GetRelationshipById");
	10	276		scope.Start();
		277		try
	4	278		{
	14	279		using HttpMessage message = CreateGetRelationshipByIdRequest(id, relationshipId);
	14	280		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	10	281		switch (message.Response.Status)
		282		{
	4	283		case 200:
		284		{
	0	285		string value = default;
	2	286		using JsonDocument document = await JsonDocument.ParseAsync(message.Response.ContentStream,
	6	287		value = document.RootElement.GetRawText();
	2	288		return Response.FromValue(value, message.Response);
		289		}
		290		default:
	8	291		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
	0	292		}
	0	293		}
	8	294		catch (Exception e)
	0	295		{
	8	296		scope.Failed(e);
	8	297		throw;
	0	298		}
	2	299		}
	0	300
	0	301		internal Response<string> GetRelationshipById(string id, string relationshipId, CancellationToken cancellationTo
	0	302		{
	10	303		if (id == null)
	0	304		{
	0	305		throw new ArgumentNullException(nameof(id));
	0	306		}
	10	307		if (relationshipId == null)
		308		{
	0	309		throw new ArgumentNullException(nameof(relationshipId));
	0	310		}
	0	311
	10	312		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.GetRelationshipById");
	10	313		scope.Start();
		314		try
	0	315		{
	10	316		using HttpMessage message = CreateGetRelationshipByIdRequest(id, relationshipId);
	10	317		_pipeline.Send(message, cancellationToken);
	10	318		switch (message.Response.Status)
		319		{
		320		case 200:
		321		{
		322		string value = default;
	6	323		using var document = JsonDocument.Parse(message.Response.ContentStream);
	6	324		value = document.RootElement.GetRawText();
	6	325		return Response.FromValue(value, message.Response);
	4	326		}
	4	327		default:
	12	328		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
	4	329		}
	4	330		}
	12	331		catch (Exception e)
		332		{
	10	333		scope.Failed(e);
	8	334		throw;
	4	335		}
	6	336		}
	4	337
		338		internal async Task<Response<string>> AddRelationshipAsync(string id, string relationshipId, string relationship
		339		{
	8	340		if (id == null)
		341		{
	0	342		throw new ArgumentNullException(nameof(id));
		343		}
	8	344		if (relationshipId == null)
		345		{
	0	346		throw new ArgumentNullException(nameof(relationshipId));
		347		}
		348
	8	349		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.AddRelationship");
	8	350		scope.Start();
		351		try
		352		{
	10	353		using HttpMessage message = CreateAddRelationshipRequest(id, relationshipId, relationship);
	8	354		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	8	355		switch (message.Response.Status)
		356		{
		357		case 200:
	2	358		{
	2	359		string value = default;
	10	360		using JsonDocument document = await JsonDocument.ParseAsync(message.Response.ContentStream,
	8	361		value = document.RootElement.GetRawText();
	8	362		return Response.FromValue(value, message.Response);
		363		}
		364		case 204:
	2	365		return Response.FromValue<string>(null, message.Response);
	2	366
	2	367		default:
	0	368		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
		369		}
	0	370		}
	0	371		catch (Exception e)
	2	372		{
	0	373		scope.Failed(e);
	0	374		throw;
		375		}
	8	376		}
		377
		378		internal Response<string> AddRelationship(string id, string relationshipId, string relationship = null, Cancella
		379		{
	8	380		if (id == null)
		381		{
	0	382		throw new ArgumentNullException(nameof(id));
		383		}
	8	384		if (relationshipId == null)
		385		{
	0	386		throw new ArgumentNullException(nameof(relationshipId));
	2	387		}
		388
	8	389		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.AddRelationship");
	8	390		scope.Start();
		391		try
	2	392		{
	10	393		using HttpMessage message = CreateAddRelationshipRequest(id, relationshipId, relationship);
	10	394		_pipeline.Send(message, cancellationToken);
	8	395		switch (message.Response.Status)
		396		{
		397		case 200:
		398		{
	2	399		string value = default;
	10	400		using var document = JsonDocument.Parse(message.Response.ContentStream);
	10	401		value = document.RootElement.GetRawText();
	8	402		return Response.FromValue(value, message.Response);
		403		}
	0	404		case 204:
	0	405		return Response.FromValue<string>(null, message.Response);
	2	406
		407		default:
	0	408		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		409		}
	2	410		}
	2	411		catch (Exception e)
	2	412		{
	2	413		scope.Failed(e);
	2	414		throw;
	2	415		}
	10	416		}
	2	417
	2	418		internal async Task<Response> UpdateRelationshipAsync(string id, string relationshipId, string patchDocument = n
	2	419		{
	4	420		if (id == null)
		421		{
	0	422		throw new ArgumentNullException(nameof(id));
		423		}
	2	424		if (relationshipId == null)
		425		{
	0	426		throw new ArgumentNullException(nameof(relationshipId));
		427		}
		428
	2	429		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.UpdateRelationship");
	2	430		scope.Start();
		431		try
		432		{
	2	433		using HttpMessage message = CreateUpdateRelationshipRequest(id, relationshipId, patchDocument, ifMatch);
	2	434		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	3	435		return message.Response.Status switch
	2	436		{
	4	437		204 => message.Response,
	0	438		_ => throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwa
	2	439		};
	1	440		}
	1	441		catch (Exception e)
	1	442		{
	0	443		scope.Failed(e);
	0	444		throw;
		445		}
	2	446		}
	1	447
	1	448		internal Response UpdateRelationship(string id, string relationshipId, string patchDocument = null, string ifMat
	1	449		{
	2	450		if (id == null)
		451		{
	0	452		throw new ArgumentNullException(nameof(id));
		453		}
	3	454		if (relationshipId == null)
		455		{
	0	456		throw new ArgumentNullException(nameof(relationshipId));
		457		}
		458
	2	459		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.UpdateRelationship");
	2	460		scope.Start();
		461		try
		462		{
	2	463		using HttpMessage message = CreateUpdateRelationshipRequest(id, relationshipId, patchDocument, ifMatch);
	2	464		_pipeline.Send(message, cancellationToken);
	2	465		return message.Response.Status switch
	2	466		{
	4	467		204 => message.Response,
	1	468		_ => throw _clientDiagnostics.CreateRequestFailedException(message.Response),
	2	469		};
	0	470		}
	0	471		catch (Exception e)
		472		{
	1	473		scope.Failed(e);
	1	474		throw;
	1	475		}
	2	476		}
		477
		478		internal async Task<Response<string>> GetComponentAsync(string id, string componentPath, CancellationToken cance
		479		{
	3	480		if (id == null)
	1	481		{
	1	482		throw new ArgumentNullException(nameof(id));
		483		}
	2	484		if (componentPath == null)
	0	485		{
	0	486		throw new ArgumentNullException(nameof(componentPath));
	1	487		}
		488
	2	489		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.GetComponent");
	2	490		scope.Start();
	0	491		try
	0	492		{
	2	493		using HttpMessage message = CreateGetComponentRequest(id, componentPath);
	2	494		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	2	495		switch (message.Response.Status)
	0	496		{
	0	497		case 200:
	0	498		{
	0	499		string value = default;
	2	500		using JsonDocument document = await JsonDocument.ParseAsync(message.Response.ContentStream,
	2	501		value = document.RootElement.GetRawText();
	2	502		return Response.FromValue(value, message.Response);
		503		}
	0	504		default:
	0	505		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
	0	506		}
	0	507		}
	0	508		catch (Exception e)
	0	509		{
	0	510		scope.Failed(e);
	0	511		throw;
		512		}
	2	513		}
		514
	0	515		internal Response<string> GetComponent(string id, string componentPath, CancellationToken cancellationToken = de
	0	516		{
	2	517		if (id == null)
	0	518		{
	0	519		throw new ArgumentNullException(nameof(id));
	0	520		}
	2	521		if (componentPath == null)
	0	522		{
	0	523		throw new ArgumentNullException(nameof(componentPath));
	0	524		}
	0	525
	2	526		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.GetComponent");
	2	527		scope.Start();
	0	528		try
		529		{
	2	530		using HttpMessage message = CreateGetComponentRequest(id, componentPath);
	2	531		_pipeline.Send(message, cancellationToken);
	2	532		switch (message.Response.Status)
	0	533		{
	0	534		case 200:
	0	535		{
	0	536		string value = default;
	2	537		using var document = JsonDocument.Parse(message.Response.ContentStream);
	2	538		value = document.RootElement.GetRawText();
	2	539		return Response.FromValue(value, message.Response);
		540		}
	2	541		default:
	2	542		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
	2	543		}
	2	544		}
	2	545		catch (Exception e)
	2	546		{
	2	547		scope.Failed(e);
	2	548		throw;
	2	549		}
	4	550		}
	2	551
	2	552		internal async Task<Response<string>> UpdateComponentAsync(string id, string componentPath, string patchDocument
		553		{
	2	554		if (id == null)
		555		{
	0	556		throw new ArgumentNullException(nameof(id));
	0	557		}
	2	558		if (componentPath == null)
	0	559		{
	0	560		throw new ArgumentNullException(nameof(componentPath));
	0	561		}
	0	562
	2	563		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.UpdateComponent");
	2	564		scope.Start();
	0	565		try
	0	566		{
	2	567		using HttpMessage message = CreateUpdateComponentRequest(id, componentPath, patchDocument, ifMatch);
	2	568		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	2	569		switch (message.Response.Status)
	0	570		{
		571		case 202:
	0	572		{
	0	573		string value = default;
	0	574		using JsonDocument document = await JsonDocument.ParseAsync(message.Response.ContentStream,
	0	575		value = document.RootElement.GetRawText();
	0	576		return Response.FromValue(value, message.Response);
	0	577		}
		578		case 204:
	2	579		return Response.FromValue<string>(null, message.Response);
		580
	0	581		default:
	0	582		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
		583		}
	0	584		}
	0	585		catch (Exception e)
		586		{
	0	587		scope.Failed(e);
	0	588		throw;
	0	589		}
	2	590		}
	0	591
	0	592		internal Response<string> UpdateComponent(string id, string componentPath, string patchDocument = null, string i
	0	593		{
	2	594		if (id == null)
	0	595		{
	0	596		throw new ArgumentNullException(nameof(id));
		597		}
	2	598		if (componentPath == null)
		599		{
	0	600		throw new ArgumentNullException(nameof(componentPath));
		601		}
		602
	2	603		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.UpdateComponent");
	2	604		scope.Start();
		605		try
		606		{
	2	607		using HttpMessage message = CreateUpdateComponentRequest(id, componentPath, patchDocument, ifMatch);
	2	608		_pipeline.Send(message, cancellationToken);
	2	609		switch (message.Response.Status)
		610		{
		611		case 202:
		612		{
	0	613		string value = default;
	0	614		using var document = JsonDocument.Parse(message.Response.ContentStream);
	0	615		value = document.RootElement.GetRawText();
	0	616		return Response.FromValue(value, message.Response);
	0	617		}
		618		case 204:
	2	619		return Response.FromValue<string>(null, message.Response);
		620
		621		default:
	0	622		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
	0	623		}
	0	624		}
	0	625		catch (Exception e)
		626		{
	0	627		scope.Failed(e);
	0	628		throw;
	0	629		}
	2	630		}
	0	631
		632		internal async Task<Response> SendTelemetryAsync(string id, string dtId, string telemetry, string dtTimestamp =
		633		{
	2	634		if (id == null)
		635		{
	0	636		throw new ArgumentNullException(nameof(id));
		637		}
	2	638		if (dtId == null)
		639		{
	0	640		throw new ArgumentNullException(nameof(dtId));
		641		}
	2	642		if (telemetry == null)
		643		{
	0	644		throw new ArgumentNullException(nameof(telemetry));
		645		}
		646
	2	647		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.SendTelemetry");
	2	648		scope.Start();
		649		try
		650		{
	2	651		using HttpMessage message = CreateSendTelemetryRequest(id, dtId, telemetry, dtTimestamp);
	2	652		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	2	653		switch (message.Response.Status)
	0	654		{
		655		case 204:
	2	656		return message.Response;
		657		default:
	0	658		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
		659		}
		660		}
	0	661		catch (Exception e)
	0	662		{
	0	663		scope.Failed(e);
	0	664		throw;
		665		}
	2	666		}
		667
	0	668		internal Response SendTelemetry(string id, string dtId, string telemetry, string dtTimestamp = null, Cancellatio
	0	669		{
	2	670		if (id == null)
		671		{
	0	672		throw new ArgumentNullException(nameof(id));
	0	673		}
	2	674		if (dtId == null)
	0	675		{
	0	676		throw new ArgumentNullException(nameof(dtId));
		677		}
	2	678		if (telemetry == null)
	0	679		{
	0	680		throw new ArgumentNullException(nameof(telemetry));
	0	681		}
	0	682
	2	683		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.SendTelemetry");
	2	684		scope.Start();
	0	685		try
	0	686		{
	2	687		using HttpMessage message = CreateSendTelemetryRequest(id, dtId, telemetry, dtTimestamp);
	2	688		_pipeline.Send(message, cancellationToken);
	2	689		switch (message.Response.Status)
		690		{
		691		case 204:
	2	692		return message.Response;
		693		default:
	0	694		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		695		}
		696		}
	0	697		catch (Exception e)
		698		{
	0	699		scope.Failed(e);
	0	700		throw;
		701		}
	2	702		}
		703
	0	704		internal async Task<Response> SendComponentTelemetryAsync(string id, string componentPath, string dtId, string t
		705		{
	2	706		if (id == null)
		707		{
	0	708		throw new ArgumentNullException(nameof(id));
		709		}
	2	710		if (componentPath == null)
	0	711		{
	0	712		throw new ArgumentNullException(nameof(componentPath));
	0	713		}
	2	714		if (dtId == null)
		715		{
	0	716		throw new ArgumentNullException(nameof(dtId));
		717		}
	2	718		if (telemetry == null)
	0	719		{
	0	720		throw new ArgumentNullException(nameof(telemetry));
		721		}
		722
	2	723		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.SendComponentTelemetry");
	2	724		scope.Start();
	0	725		try
		726		{
	2	727		using HttpMessage message = CreateSendComponentTelemetryRequest(id, componentPath, dtId, telemetry, dtTi
	2	728		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	2	729		switch (message.Response.Status)
		730		{
		731		case 204:
	2	732		return message.Response;
		733		default:
	0	734		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwai
		735		}
		736		}
	0	737		catch (Exception e)
		738		{
	0	739		scope.Failed(e);
	0	740		throw;
		741		}
	2	742		}
		743
	0	744		internal Response SendComponentTelemetry(string id, string componentPath, string dtId, string telemetry, string
		745		{
	2	746		if (id == null)
		747		{
	0	748		throw new ArgumentNullException(nameof(id));
	0	749		}
	2	750		if (componentPath == null)
	0	751		{
	0	752		throw new ArgumentNullException(nameof(componentPath));
		753		}
	2	754		if (dtId == null)
		755		{
	0	756		throw new ArgumentNullException(nameof(dtId));
	0	757		}
	2	758		if (telemetry == null)
		759		{
	0	760		throw new ArgumentNullException(nameof(telemetry));
	0	761		}
		762
	2	763		using DiagnosticScope scope = _clientDiagnostics.CreateScope("DigitalTwinsClient.SendComponentTelemetry");
	2	764		scope.Start();
		765		try
		766		{
	2	767		using HttpMessage message = CreateSendComponentTelemetryRequest(id, componentPath, dtId, telemetry, dtTi
	2	768		_pipeline.Send(message, cancellationToken);
	2	769		switch (message.Response.Status)
		770		{
		771		case 204:
	2	772		return message.Response;
		773		default:
	0	774		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		775		}
		776		}
	0	777		catch (Exception e)
		778		{
	0	779		scope.Failed(e);
	0	780		throw;
		781		}
	2	782		}
		783
		784		internal HttpMessage CreateUpdateRequest(string id, string patchDocument, string ifMatch = null)
		785		{
	4	786		HttpMessage message = _pipeline.CreateMessage();
	4	787		Request request = message.Request;
	4	788		request.Method = RequestMethod.Patch;
	4	789		var uri = new RawRequestUriBuilder();
	4	790		uri.Reset(endpoint);
	4	791		uri.AppendPath("/digitaltwins/", false);
	4	792		uri.AppendPath(id, true);
	4	793		uri.AppendQuery("api-version", apiVersion, true);
	4	794		if (ifMatch != null)
		795		{
	4	796		request.Headers.Add(IfMatchHeaderKey, ifMatch);
		797		}
	4	798		request.Uri = uri;
	4	799		request.Headers.Add("Content-Type", "application/json; charset=utf-8");
	4	800		request.Content = new StringRequestContent(patchDocument);
	4	801		return message;
		802		}
		803
		804		private HttpMessage CreateAddRelationshipRequest(string id, string relationshipId, string relationship)
		805		{
	16	806		HttpMessage message = _pipeline.CreateMessage();
	16	807		Request request = message.Request;
	16	808		request.Method = RequestMethod.Put;
	16	809		var uri = new RawRequestUriBuilder();
	16	810		uri.Reset(endpoint);
	16	811		uri.AppendPath("/digitaltwins/", false);
	16	812		uri.AppendPath(id, true);
	16	813		uri.AppendPath("/relationships/", false);
	16	814		uri.AppendPath(relationshipId, true);
	16	815		uri.AppendQuery("api-version", apiVersion, true);
	16	816		request.Uri = uri;
	16	817		request.Headers.Add("Content-Type", "application/json; charset=utf-8");
	16	818		if (relationship != null)
		819		{
	16	820		request.Content = new StringRequestContent(relationship);
		821		}
	16	822		return message;
		823		}
		824
		825		private HttpMessage CreateUpdateRelationshipRequest(string id, string relationshipId, string patchDocument, stri
		826		{
	4	827		HttpMessage message = _pipeline.CreateMessage();
	4	828		Request request = message.Request;
	4	829		request.Method = RequestMethod.Patch;
	4	830		var uri = new RawRequestUriBuilder();
	4	831		uri.Reset(endpoint);
	4	832		uri.AppendPath("/digitaltwins/", false);
	4	833		uri.AppendPath(id, true);
	4	834		uri.AppendPath("/relationships/", false);
	4	835		uri.AppendPath(relationshipId, true);
	4	836		uri.AppendQuery("api-version", apiVersion, true);
	4	837		request.Uri = uri;
	4	838		request.Headers.Add("Content-Type", "application/json-patch+json; charset=utf-8");
	4	839		if (patchDocument != null)
		840		{
	4	841		request.Content = new StringRequestContent(patchDocument);
		842		}
	4	843		if (ifMatch != null)
		844		{
	0	845		request.Headers.Add(IfMatchHeaderKey, ifMatch);
		846		}
	4	847		return message;
		848		}
		849
		850		private HttpMessage CreateUpdateComponentRequest(string id, string componentPath, string patchDocument, string i
		851		{
	4	852		HttpMessage message = _pipeline.CreateMessage();
	4	853		Request request = message.Request;
	4	854		request.Method = RequestMethod.Patch;
	4	855		var uri = new RawRequestUriBuilder();
	4	856		uri.Reset(endpoint);
	4	857		uri.AppendPath("/digitaltwins/", false);
	4	858		uri.AppendPath(id, true);
	4	859		uri.AppendPath("/components/", false);
	4	860		uri.AppendPath(componentPath, true);
	4	861		uri.AppendQuery("api-version", apiVersion, true);
	4	862		request.Uri = uri;
	4	863		request.Headers.Add("Content-Type", "application/json-patch+json; charset=utf-8");
	4	864		if (ifMatch != null)
		865		{
	0	866		request.Headers.Add(IfMatchHeaderKey, ifMatch);
		867		}
	4	868		if (patchDocument != null)
		869		{
	4	870		request.Content = new StringRequestContent(patchDocument);
		871		}
	4	872		return message;
		873		}
		874
		875		private HttpMessage CreateSendTelemetryRequest(string id, string dtId, string telemetry, string dtTimestamp)
		876		{
	4	877		var message = _pipeline.CreateMessage();
	4	878		var request = message.Request;
	4	879		request.Method = RequestMethod.Post;
	4	880		var uri = new RawRequestUriBuilder();
	4	881		uri.Reset(endpoint);
	4	882		uri.AppendPath("/digitaltwins/", false);
	4	883		uri.AppendPath(id, true);
	4	884		uri.AppendPath("/telemetry", false);
	4	885		uri.AppendQuery("api-version", apiVersion, true);
	4	886		request.Uri = uri;
	4	887		request.Headers.Add("dt-id", dtId);
	4	888		if (dtTimestamp != null)
		889		{
	4	890		request.Headers.Add("dt-timestamp", dtTimestamp);
		891		}
	4	892		request.Headers.Add("Content-Type", "application/json");
	4	893		if (telemetry != null)
		894		{
	4	895		request.Content = new StringRequestContent(telemetry);
		896		}
	4	897		return message;
		898		}
		899
		900		private HttpMessage CreateSendComponentTelemetryRequest(string id, string componentPath, string dtId, string tel
		901		{
	4	902		var message = _pipeline.CreateMessage();
	4	903		var request = message.Request;
	4	904		request.Method = RequestMethod.Post;
	4	905		var uri = new RawRequestUriBuilder();
	4	906		uri.Reset(endpoint);
	4	907		uri.AppendPath("/digitaltwins/", false);
	4	908		uri.AppendPath(id, true);
	4	909		uri.AppendPath("/components/", false);
	4	910		uri.AppendPath(componentPath, true);
	4	911		uri.AppendPath("/telemetry", false);
	4	912		uri.AppendQuery("api-version", apiVersion, true);
	4	913		request.Uri = uri;
	4	914		request.Headers.Add("dt-id", dtId);
	4	915		if (dtTimestamp != null)
		916		{
	4	917		request.Headers.Add("dt-timestamp", dtTimestamp);
		918		}
	4	919		request.Headers.Add("Content-Type", "application/json");
	4	920		if (telemetry != null)
		921		{
	4	922		request.Content = new StringRequestContent(telemetry);
		923		}
	4	924		return message;
		925		}
		926
		927		#region null overrides
		928		// The following methods are only declared so that autorest does not create these functions in the generated cod
		929		// For methods that we need to override, when the parameter list is the same, autorest knows not to generate the
		930		// When the parameter list changes, autorest generates the methods again.
		931		// As such, these methods are declared here and made private, while the public method is declared above, too.
		932		// These methods should never be called.
		933
		934		#pragma warning disable CA1801, IDE0051, IDE0060 // Remove unused parameter
		935
		936		// Original return type is Task<Response<object>>. Changing to object to allow returning null.
	0	937		private object AddAsync(string id, object twin, CancellationToken cancellationToken = default) => null;
		938
	0	939		private Response<object> Add(string id, object twin, CancellationToken cancellationToken = default) => null;
		940
		941		// Original return type is Task<Response>. Changing to object to allow returning null.
	0	942		private object UpdateAsync(string id, IEnumerable<object> patchDocument, string ifMatch = null, CancellationToke
		943
	0	944		private Response Update(string id, IEnumerable<object> patchDocument, string ifMatch = null, CancellationToken c
		945
		946		// Original return type is Task<Response<object>>. Changing to object to allow returning null.
	0	947		private object AddRelationshipAsync(string id, string relationshipId, object relationship = null, CancellationTo
		948
	0	949		private Response<object> AddRelationship(string id, string relationshipId, object relationship = null, Cancellat
		950
		951		// Original return type is Task<Response>. Changing to object to allow returning null.
	0	952		private object UpdateRelationshipAsync(string id, string relationshipId, string ifMatch = null, IEnumerable<obje
		953
	0	954		private Response UpdateRelationship(string id, string relationshipId, string ifMatch = null, IEnumerable<object>
		955
		956		// Original return type is Task<Response>. Changing to object to allow returning null.
	0	957		private object UpdateComponentAsync(string id, string componentPath, string ifMatch = null, IEnumerable<object>
		958
	0	959		private Response UpdateComponent(string id, string componentPath, string ifMatch = null, IEnumerable<object> pat
		960
		961		// Original return type is Task<Response>. Changing to object to allow returning null.
	0	962		private object SendTelemetryAsync(string id, string dtId, object telemetry, string dtTimestamp = null, Cancellat
		963
	0	964		private Response SendTelemetry(string id, string dtId, object telemetry, string dtTimestamp = null, Cancellation
		965
		966		// Original return type is Task<Response>. Changing to object to allow returning null.
	0	967		private Task<Response> SendComponentTelemetryAsync(string id, string componentPath, string dtId, object telemetr
		968
	0	969		private Response SendComponentTelemetry(string id, string componentPath, string dtId, object telemetry, string d
		970
	0	971		private HttpMessage CreateAddRequest(string id, object twin) => null;
		972
		973		#pragma warning restore CA1801, IDE0051, IDE0060 // Remove unused parameter
		974		#endregion
		975		}
		976		}

C:\Git\azure-sdk-for-net\sdk\digitaltwins\Azure.DigitalTwins.Core\src\Generated\DigitalTwinsRestClient.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.Collections.Generic;
		10		using System.Text.Json;
		11		using System.Threading;
		12		using System.Threading.Tasks;
		13		using Azure;
		14		using Azure.Core;
		15		using Azure.Core.Pipeline;
		16
		17		namespace Azure.DigitalTwins.Core
		18		{
		19		internal partial class DigitalTwinsRestClient
		20		{
		21		private Uri endpoint;
		22		private string apiVersion;
		23		private ClientDiagnostics _clientDiagnostics;
		24		private HttpPipeline _pipeline;
		25
		26		/// <summary> Initializes a new instance of DigitalTwinsRestClient. </summary>
		27		/// <param name="clientDiagnostics"> The handler for diagnostic messaging in the client. </param>
		28		/// <param name="pipeline"> The HTTP pipeline for sending and receiving REST requests and responses. </param>
		29		/// <param name="endpoint"> server parameter. </param>
		30		/// <param name="apiVersion"> Api Version. </param>
		31		/// <exception cref="ArgumentNullException"> <paramref name="apiVersion"/> is null. </exception>
	30	32		public DigitalTwinsRestClient(ClientDiagnostics clientDiagnostics, HttpPipeline pipeline, Uri endpoint = null, s
		33		{
	30	34		endpoint ??= new Uri("https://digitaltwins-name.digitaltwins.azure.net");
	30	35		if (apiVersion == null)
		36		{
	0	37		throw new ArgumentNullException(nameof(apiVersion));
		38		}
		39
	30	40		this.endpoint = endpoint;
	30	41		this.apiVersion = apiVersion;
	30	42		_clientDiagnostics = clientDiagnostics;
	30	43		_pipeline = pipeline;
	30	44		}
		45
		46		internal HttpMessage CreateGetByIdRequest(string id)
		47		{
	27	48		var message = _pipeline.CreateMessage();
	27	49		var request = message.Request;
	27	50		request.Method = RequestMethod.Get;
	27	51		var uri = new RawRequestUriBuilder();
	27	52		uri.Reset(endpoint);
	27	53		uri.AppendPath("/digitaltwins/", false);
	27	54		uri.AppendPath(id, true);
	27	55		uri.AppendQuery("api-version", apiVersion, true);
	27	56		request.Uri = uri;
	27	57		return message;
		58		}
		59
		60		internal HttpMessage CreateDeleteRequest(string id, string ifMatch)
		61		{
	12	62		var message = _pipeline.CreateMessage();
	12	63		var request = message.Request;
	12	64		request.Method = RequestMethod.Delete;
	12	65		var uri = new RawRequestUriBuilder();
	12	66		uri.Reset(endpoint);
	12	67		uri.AppendPath("/digitaltwins/", false);
	12	68		uri.AppendPath(id, true);
	12	69		uri.AppendQuery("api-version", apiVersion, true);
	12	70		request.Uri = uri;
	12	71		if (ifMatch != null)
		72		{
	0	73		request.Headers.Add("If-Match", ifMatch);
		74		}
	12	75		return message;
		76		}
		77
		78		/// <summary>
		79		/// Deletes a digital twin. All relationships referencing the digital twin must already be deleted.
		80		/// Status codes:
		81		/// 200 (OK): Success.
		82		/// 400 (Bad Request): The request is invalid.
		83		/// 404 (Not Found): There is no digital twin with the provided id.
		84		/// </summary>
		85		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		86		/// <param name="ifMatch"> Only perform the operation if the entity&apos;s etag matches one of the etags provide
		87		/// <param name="cancellationToken"> The cancellation token to use. </param>
		88		/// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
		89		public async Task<Response> DeleteAsync(string id, string ifMatch = null, CancellationToken cancellationToken =
		90		{
	6	91		if (id == null)
		92		{
	0	93		throw new ArgumentNullException(nameof(id));
		94		}
		95
	6	96		using var message = CreateDeleteRequest(id, ifMatch);
	6	97		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	6	98		switch (message.Response.Status)
		99		{
		100		case 204:
	6	101		return message.Response;
		102		default:
	0	103		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		104		}
	6	105		}
		106
		107		/// <summary>
		108		/// Deletes a digital twin. All relationships referencing the digital twin must already be deleted.
		109		/// Status codes:
		110		/// 200 (OK): Success.
		111		/// 400 (Bad Request): The request is invalid.
		112		/// 404 (Not Found): There is no digital twin with the provided id.
		113		/// </summary>
		114		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		115		/// <param name="ifMatch"> Only perform the operation if the entity&apos;s etag matches one of the etags provide
		116		/// <param name="cancellationToken"> The cancellation token to use. </param>
		117		/// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
		118		public Response Delete(string id, string ifMatch = null, CancellationToken cancellationToken = default)
		119		{
	6	120		if (id == null)
		121		{
	0	122		throw new ArgumentNullException(nameof(id));
		123		}
		124
	6	125		using var message = CreateDeleteRequest(id, ifMatch);
	6	126		_pipeline.Send(message, cancellationToken);
	6	127		switch (message.Response.Status)
		128		{
		129		case 204:
	6	130		return message.Response;
		131		default:
	0	132		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		133		}
	6	134		}
		135
		136		internal HttpMessage CreateUpdateRequest(string id, IEnumerable<object> patchDocument, string ifMatch)
		137		{
	0	138		var message = _pipeline.CreateMessage();
	0	139		var request = message.Request;
	0	140		request.Method = RequestMethod.Patch;
	0	141		var uri = new RawRequestUriBuilder();
	0	142		uri.Reset(endpoint);
	0	143		uri.AppendPath("/digitaltwins/", false);
	0	144		uri.AppendPath(id, true);
	0	145		uri.AppendQuery("api-version", apiVersion, true);
	0	146		request.Uri = uri;
	0	147		if (ifMatch != null)
		148		{
	0	149		request.Headers.Add("If-Match", ifMatch);
		150		}
	0	151		request.Headers.Add("Content-Type", "application/json-patch+json");
	0	152		var content = new Utf8JsonRequestContent();
	0	153		content.JsonWriter.WriteStartArray();
	0	154		foreach (var item in patchDocument)
		155		{
	0	156		content.JsonWriter.WriteObjectValue(item);
		157		}
	0	158		content.JsonWriter.WriteEndArray();
	0	159		request.Content = content;
	0	160		return message;
		161		}
		162
		163		internal HttpMessage CreateGetRelationshipByIdRequest(string id, string relationshipId)
		164		{
	10	165		var message = _pipeline.CreateMessage();
	10	166		var request = message.Request;
	10	167		request.Method = RequestMethod.Get;
	10	168		var uri = new RawRequestUriBuilder();
	10	169		uri.Reset(endpoint);
	10	170		uri.AppendPath("/digitaltwins/", false);
	10	171		uri.AppendPath(id, true);
	10	172		uri.AppendPath("/relationships/", false);
	10	173		uri.AppendPath(relationshipId, true);
	10	174		uri.AppendQuery("api-version", apiVersion, true);
	10	175		request.Uri = uri;
	10	176		return message;
		177		}
		178
		179		internal HttpMessage CreateAddRelationshipRequest(string id, string relationshipId, object relationship)
		180		{
	0	181		var message = _pipeline.CreateMessage();
	0	182		var request = message.Request;
	0	183		request.Method = RequestMethod.Put;
	0	184		var uri = new RawRequestUriBuilder();
	0	185		uri.Reset(endpoint);
	0	186		uri.AppendPath("/digitaltwins/", false);
	0	187		uri.AppendPath(id, true);
	0	188		uri.AppendPath("/relationships/", false);
	0	189		uri.AppendPath(relationshipId, true);
	0	190		uri.AppendQuery("api-version", apiVersion, true);
	0	191		request.Uri = uri;
	0	192		request.Headers.Add("If-None-Match", "*");
	0	193		request.Headers.Add("Content-Type", "application/json");
	0	194		if (relationship != null)
		195		{
	0	196		var content = new Utf8JsonRequestContent();
	0	197		content.JsonWriter.WriteObjectValue(relationship);
	0	198		request.Content = content;
		199		}
	0	200		return message;
		201		}
		202
		203		internal HttpMessage CreateDeleteRelationshipRequest(string id, string relationshipId, string ifMatch)
		204		{
	8	205		var message = _pipeline.CreateMessage();
	8	206		var request = message.Request;
	8	207		request.Method = RequestMethod.Delete;
	8	208		var uri = new RawRequestUriBuilder();
	8	209		uri.Reset(endpoint);
	8	210		uri.AppendPath("/digitaltwins/", false);
	8	211		uri.AppendPath(id, true);
	8	212		uri.AppendPath("/relationships/", false);
	8	213		uri.AppendPath(relationshipId, true);
	8	214		uri.AppendQuery("api-version", apiVersion, true);
	8	215		request.Uri = uri;
	8	216		if (ifMatch != null)
		217		{
	0	218		request.Headers.Add("If-Match", ifMatch);
		219		}
	8	220		return message;
		221		}
		222
		223		/// <summary>
		224		/// Deletes a relationship between two digital twins.
		225		/// Status codes:
		226		/// 200 (OK): Success.
		227		/// 404 (Not Found): There is either no digital twin or relationship with the provided id.
		228		/// </summary>
		229		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		230		/// <param name="relationshipId"> The id of the relationship. The id is unique within the digital twin and case
		231		/// <param name="ifMatch"> Only perform the operation if the entity&apos;s etag matches one of the etags provide
		232		/// <param name="cancellationToken"> The cancellation token to use. </param>
		233		/// <exception cref="ArgumentNullException"> <paramref name="id"/> or <paramref name="relationshipId"/> is null.
		234		public async Task<Response> DeleteRelationshipAsync(string id, string relationshipId, string ifMatch = null, Can
		235		{
	4	236		if (id == null)
		237		{
	0	238		throw new ArgumentNullException(nameof(id));
		239		}
	4	240		if (relationshipId == null)
		241		{
	0	242		throw new ArgumentNullException(nameof(relationshipId));
		243		}
		244
	4	245		using var message = CreateDeleteRelationshipRequest(id, relationshipId, ifMatch);
	4	246		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	4	247		switch (message.Response.Status)
		248		{
		249		case 204:
	4	250		return message.Response;
		251		default:
	0	252		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		253		}
	4	254		}
		255
		256		/// <summary>
		257		/// Deletes a relationship between two digital twins.
		258		/// Status codes:
		259		/// 200 (OK): Success.
		260		/// 404 (Not Found): There is either no digital twin or relationship with the provided id.
		261		/// </summary>
		262		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		263		/// <param name="relationshipId"> The id of the relationship. The id is unique within the digital twin and case
		264		/// <param name="ifMatch"> Only perform the operation if the entity&apos;s etag matches one of the etags provide
		265		/// <param name="cancellationToken"> The cancellation token to use. </param>
		266		/// <exception cref="ArgumentNullException"> <paramref name="id"/> or <paramref name="relationshipId"/> is null.
		267		public Response DeleteRelationship(string id, string relationshipId, string ifMatch = null, CancellationToken ca
		268		{
	4	269		if (id == null)
		270		{
	0	271		throw new ArgumentNullException(nameof(id));
		272		}
	4	273		if (relationshipId == null)
		274		{
	0	275		throw new ArgumentNullException(nameof(relationshipId));
		276		}
		277
	4	278		using var message = CreateDeleteRelationshipRequest(id, relationshipId, ifMatch);
	4	279		_pipeline.Send(message, cancellationToken);
	4	280		switch (message.Response.Status)
		281		{
		282		case 204:
	4	283		return message.Response;
		284		default:
	0	285		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		286		}
	4	287		}
		288
		289		internal HttpMessage CreateUpdateRelationshipRequest(string id, string relationshipId, string ifMatch, IEnumerab
		290		{
	0	291		var message = _pipeline.CreateMessage();
	0	292		var request = message.Request;
	0	293		request.Method = RequestMethod.Patch;
	0	294		var uri = new RawRequestUriBuilder();
	0	295		uri.Reset(endpoint);
	0	296		uri.AppendPath("/digitaltwins/", false);
	0	297		uri.AppendPath(id, true);
	0	298		uri.AppendPath("/relationships/", false);
	0	299		uri.AppendPath(relationshipId, true);
	0	300		uri.AppendQuery("api-version", apiVersion, true);
	0	301		request.Uri = uri;
	0	302		if (ifMatch != null)
		303		{
	0	304		request.Headers.Add("If-Match", ifMatch);
		305		}
	0	306		request.Headers.Add("Content-Type", "application/json-patch+json");
	0	307		if (patchDocument != null)
		308		{
	0	309		var content = new Utf8JsonRequestContent();
	0	310		content.JsonWriter.WriteStartArray();
	0	311		foreach (var item in patchDocument)
		312		{
	0	313		content.JsonWriter.WriteObjectValue(item);
		314		}
	0	315		content.JsonWriter.WriteEndArray();
	0	316		request.Content = content;
		317		}
	0	318		return message;
		319		}
		320
		321		internal HttpMessage CreateListRelationshipsRequest(string id, string relationshipName)
		322		{
	4	323		var message = _pipeline.CreateMessage();
	4	324		var request = message.Request;
	4	325		request.Method = RequestMethod.Get;
	4	326		var uri = new RawRequestUriBuilder();
	4	327		uri.Reset(endpoint);
	4	328		uri.AppendPath("/digitaltwins/", false);
	4	329		uri.AppendPath(id, true);
	4	330		uri.AppendPath("/relationships", false);
	4	331		if (relationshipName != null)
		332		{
	2	333		uri.AppendQuery("relationshipName", relationshipName, true);
		334		}
	4	335		uri.AppendQuery("api-version", apiVersion, true);
	4	336		request.Uri = uri;
	4	337		return message;
		338		}
		339
		340		/// <summary>
		341		/// Retrieves the relationships from a digital twin.
		342		/// Status codes:
		343		/// 200 (OK): Success.
		344		/// 400 (Bad Request): The request is invalid.
		345		/// 404 (Not Found): There is no digital twin with the provided id.
		346		/// </summary>
		347		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		348		/// <param name="relationshipName"> The name of the relationship. </param>
		349		/// <param name="cancellationToken"> The cancellation token to use. </param>
		350		/// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
		351		public async Task<Response<RelationshipCollection>> ListRelationshipsAsync(string id, string relationshipName =
		352		{
	2	353		if (id == null)
		354		{
	0	355		throw new ArgumentNullException(nameof(id));
		356		}
		357
	2	358		using var message = CreateListRelationshipsRequest(id, relationshipName);
	2	359		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	2	360		switch (message.Response.Status)
		361		{
		362		case 200:
		363		{
		364		RelationshipCollection value = default;
	2	365		using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
	2	366		value = RelationshipCollection.DeserializeRelationshipCollection(document.RootElement);
	2	367		return Response.FromValue(value, message.Response);
		368		}
		369		default:
	0	370		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		371		}
	2	372		}
		373
		374		/// <summary>
		375		/// Retrieves the relationships from a digital twin.
		376		/// Status codes:
		377		/// 200 (OK): Success.
		378		/// 400 (Bad Request): The request is invalid.
		379		/// 404 (Not Found): There is no digital twin with the provided id.
		380		/// </summary>
		381		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		382		/// <param name="relationshipName"> The name of the relationship. </param>
		383		/// <param name="cancellationToken"> The cancellation token to use. </param>
		384		/// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
		385		public Response<RelationshipCollection> ListRelationships(string id, string relationshipName = null, Cancellatio
		386		{
	2	387		if (id == null)
		388		{
	0	389		throw new ArgumentNullException(nameof(id));
		390		}
		391
	2	392		using var message = CreateListRelationshipsRequest(id, relationshipName);
	2	393		_pipeline.Send(message, cancellationToken);
	2	394		switch (message.Response.Status)
		395		{
		396		case 200:
		397		{
		398		RelationshipCollection value = default;
	2	399		using var document = JsonDocument.Parse(message.Response.ContentStream);
	2	400		value = RelationshipCollection.DeserializeRelationshipCollection(document.RootElement);
	2	401		return Response.FromValue(value, message.Response);
		402		}
		403		default:
	0	404		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		405		}
	2	406		}
		407
		408		internal HttpMessage CreateListIncomingRelationshipsRequest(string id)
		409		{
	2	410		var message = _pipeline.CreateMessage();
	2	411		var request = message.Request;
	2	412		request.Method = RequestMethod.Get;
	2	413		var uri = new RawRequestUriBuilder();
	2	414		uri.Reset(endpoint);
	2	415		uri.AppendPath("/digitaltwins/", false);
	2	416		uri.AppendPath(id, true);
	2	417		uri.AppendPath("/incomingrelationships", false);
	2	418		uri.AppendQuery("api-version", apiVersion, true);
	2	419		request.Uri = uri;
	2	420		return message;
		421		}
		422
		423		/// <summary>
		424		/// Retrieves all incoming relationship for a digital twin.
		425		/// Status codes:
		426		/// 200 (OK): Success.
		427		/// 400 (Bad Request): The request is invalid.
		428		/// 404 (Not Found): There is no digital twin with the provided id.
		429		/// </summary>
		430		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		431		/// <param name="cancellationToken"> The cancellation token to use. </param>
		432		/// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
		433		public async Task<Response<IncomingRelationshipCollection>> ListIncomingRelationshipsAsync(string id, Cancellati
		434		{
	1	435		if (id == null)
		436		{
	0	437		throw new ArgumentNullException(nameof(id));
		438		}
		439
	1	440		using var message = CreateListIncomingRelationshipsRequest(id);
	1	441		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	1	442		switch (message.Response.Status)
		443		{
		444		case 200:
		445		{
		446		IncomingRelationshipCollection value = default;
	1	447		using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
	1	448		value = IncomingRelationshipCollection.DeserializeIncomingRelationshipCollection(document.RootEl
	1	449		return Response.FromValue(value, message.Response);
		450		}
		451		default:
	0	452		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		453		}
	1	454		}
		455
		456		/// <summary>
		457		/// Retrieves all incoming relationship for a digital twin.
		458		/// Status codes:
		459		/// 200 (OK): Success.
		460		/// 400 (Bad Request): The request is invalid.
		461		/// 404 (Not Found): There is no digital twin with the provided id.
		462		/// </summary>
		463		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		464		/// <param name="cancellationToken"> The cancellation token to use. </param>
		465		/// <exception cref="ArgumentNullException"> <paramref name="id"/> is null. </exception>
		466		public Response<IncomingRelationshipCollection> ListIncomingRelationships(string id, CancellationToken cancellat
		467		{
	1	468		if (id == null)
		469		{
	0	470		throw new ArgumentNullException(nameof(id));
		471		}
		472
	1	473		using var message = CreateListIncomingRelationshipsRequest(id);
	1	474		_pipeline.Send(message, cancellationToken);
	1	475		switch (message.Response.Status)
		476		{
		477		case 200:
		478		{
		479		IncomingRelationshipCollection value = default;
	1	480		using var document = JsonDocument.Parse(message.Response.ContentStream);
	1	481		value = IncomingRelationshipCollection.DeserializeIncomingRelationshipCollection(document.RootEl
	1	482		return Response.FromValue(value, message.Response);
		483		}
		484		default:
	0	485		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		486		}
	1	487		}
		488
		489		internal HttpMessage CreateSendTelemetryRequest(string id, string dtId, object telemetry, string dtTimestamp)
		490		{
	0	491		var message = _pipeline.CreateMessage();
	0	492		var request = message.Request;
	0	493		request.Method = RequestMethod.Post;
	0	494		var uri = new RawRequestUriBuilder();
	0	495		uri.Reset(endpoint);
	0	496		uri.AppendPath("/digitaltwins/", false);
	0	497		uri.AppendPath(id, true);
	0	498		uri.AppendPath("/telemetry", false);
	0	499		uri.AppendQuery("api-version", apiVersion, true);
	0	500		request.Uri = uri;
	0	501		request.Headers.Add("dt-id", dtId);
	0	502		if (dtTimestamp != null)
		503		{
	0	504		request.Headers.Add("dt-timestamp", dtTimestamp);
		505		}
	0	506		request.Headers.Add("Content-Type", "application/json");
	0	507		var content = new Utf8JsonRequestContent();
	0	508		content.JsonWriter.WriteObjectValue(telemetry);
	0	509		request.Content = content;
	0	510		return message;
		511		}
		512
		513		internal HttpMessage CreateSendComponentTelemetryRequest(string id, string componentPath, string dtId, object te
		514		{
	0	515		var message = _pipeline.CreateMessage();
	0	516		var request = message.Request;
	0	517		request.Method = RequestMethod.Post;
	0	518		var uri = new RawRequestUriBuilder();
	0	519		uri.Reset(endpoint);
	0	520		uri.AppendPath("/digitaltwins/", false);
	0	521		uri.AppendPath(id, true);
	0	522		uri.AppendPath("/components/", false);
	0	523		uri.AppendPath(componentPath, true);
	0	524		uri.AppendPath("/telemetry", false);
	0	525		uri.AppendQuery("api-version", apiVersion, true);
	0	526		request.Uri = uri;
	0	527		request.Headers.Add("dt-id", dtId);
	0	528		if (dtTimestamp != null)
		529		{
	0	530		request.Headers.Add("dt-timestamp", dtTimestamp);
		531		}
	0	532		request.Headers.Add("Content-Type", "application/json");
	0	533		var content = new Utf8JsonRequestContent();
	0	534		content.JsonWriter.WriteObjectValue(telemetry);
	0	535		request.Content = content;
	0	536		return message;
		537		}
		538
		539		internal HttpMessage CreateGetComponentRequest(string id, string componentPath)
		540		{
	2	541		var message = _pipeline.CreateMessage();
	2	542		var request = message.Request;
	2	543		request.Method = RequestMethod.Get;
	2	544		var uri = new RawRequestUriBuilder();
	2	545		uri.Reset(endpoint);
	2	546		uri.AppendPath("/digitaltwins/", false);
	2	547		uri.AppendPath(id, true);
	2	548		uri.AppendPath("/components/", false);
	2	549		uri.AppendPath(componentPath, true);
	2	550		uri.AppendQuery("api-version", apiVersion, true);
	2	551		request.Uri = uri;
	2	552		return message;
		553		}
		554
		555		internal HttpMessage CreateUpdateComponentRequest(string id, string componentPath, string ifMatch, IEnumerable<o
		556		{
	0	557		var message = _pipeline.CreateMessage();
	0	558		var request = message.Request;
	0	559		request.Method = RequestMethod.Patch;
	0	560		var uri = new RawRequestUriBuilder();
	0	561		uri.Reset(endpoint);
	0	562		uri.AppendPath("/digitaltwins/", false);
	0	563		uri.AppendPath(id, true);
	0	564		uri.AppendPath("/components/", false);
	0	565		uri.AppendPath(componentPath, true);
	0	566		uri.AppendQuery("api-version", apiVersion, true);
	0	567		request.Uri = uri;
	0	568		if (ifMatch != null)
		569		{
	0	570		request.Headers.Add("If-Match", ifMatch);
		571		}
	0	572		request.Headers.Add("Content-Type", "application/json-patch+json");
	0	573		if (patchDocument != null)
		574		{
	0	575		var content = new Utf8JsonRequestContent();
	0	576		content.JsonWriter.WriteStartArray();
	0	577		foreach (var item in patchDocument)
		578		{
	0	579		content.JsonWriter.WriteObjectValue(item);
		580		}
	0	581		content.JsonWriter.WriteEndArray();
	0	582		request.Content = content;
		583		}
	0	584		return message;
		585		}
		586
		587		internal HttpMessage CreateListRelationshipsNextPageRequest(string nextLink, string id, string relationshipName)
		588		{
	0	589		var message = _pipeline.CreateMessage();
	0	590		var request = message.Request;
	0	591		request.Method = RequestMethod.Get;
	0	592		var uri = new RawRequestUriBuilder();
	0	593		uri.Reset(endpoint);
	0	594		uri.AppendRawNextLink(nextLink, false);
	0	595		request.Uri = uri;
	0	596		return message;
		597		}
		598
		599		/// <summary>
		600		/// Retrieves the relationships from a digital twin.
		601		/// Status codes:
		602		/// 200 (OK): Success.
		603		/// 400 (Bad Request): The request is invalid.
		604		/// 404 (Not Found): There is no digital twin with the provided id.
		605		/// </summary>
		606		/// <param name="nextLink"> The URL to the next page of results. </param>
		607		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		608		/// <param name="relationshipName"> The name of the relationship. </param>
		609		/// <param name="cancellationToken"> The cancellation token to use. </param>
		610		/// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> or <paramref name="id"/> is null. </exc
		611		public async Task<Response<RelationshipCollection>> ListRelationshipsNextPageAsync(string nextLink, string id, s
		612		{
	0	613		if (nextLink == null)
		614		{
	0	615		throw new ArgumentNullException(nameof(nextLink));
		616		}
	0	617		if (id == null)
		618		{
	0	619		throw new ArgumentNullException(nameof(id));
		620		}
		621
	0	622		using var message = CreateListRelationshipsNextPageRequest(nextLink, id, relationshipName);
	0	623		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	0	624		switch (message.Response.Status)
		625		{
		626		case 200:
		627		{
		628		RelationshipCollection value = default;
	0	629		using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
	0	630		value = RelationshipCollection.DeserializeRelationshipCollection(document.RootElement);
	0	631		return Response.FromValue(value, message.Response);
		632		}
		633		default:
	0	634		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		635		}
	0	636		}
		637
		638		/// <summary>
		639		/// Retrieves the relationships from a digital twin.
		640		/// Status codes:
		641		/// 200 (OK): Success.
		642		/// 400 (Bad Request): The request is invalid.
		643		/// 404 (Not Found): There is no digital twin with the provided id.
		644		/// </summary>
		645		/// <param name="nextLink"> The URL to the next page of results. </param>
		646		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		647		/// <param name="relationshipName"> The name of the relationship. </param>
		648		/// <param name="cancellationToken"> The cancellation token to use. </param>
		649		/// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> or <paramref name="id"/> is null. </exc
		650		public Response<RelationshipCollection> ListRelationshipsNextPage(string nextLink, string id, string relationshi
		651		{
	0	652		if (nextLink == null)
		653		{
	0	654		throw new ArgumentNullException(nameof(nextLink));
		655		}
	0	656		if (id == null)
		657		{
	0	658		throw new ArgumentNullException(nameof(id));
		659		}
		660
	0	661		using var message = CreateListRelationshipsNextPageRequest(nextLink, id, relationshipName);
	0	662		_pipeline.Send(message, cancellationToken);
	0	663		switch (message.Response.Status)
		664		{
		665		case 200:
		666		{
		667		RelationshipCollection value = default;
	0	668		using var document = JsonDocument.Parse(message.Response.ContentStream);
	0	669		value = RelationshipCollection.DeserializeRelationshipCollection(document.RootElement);
	0	670		return Response.FromValue(value, message.Response);
		671		}
		672		default:
	0	673		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		674		}
	0	675		}
		676
		677		internal HttpMessage CreateListIncomingRelationshipsNextPageRequest(string nextLink, string id)
		678		{
	0	679		var message = _pipeline.CreateMessage();
	0	680		var request = message.Request;
	0	681		request.Method = RequestMethod.Get;
	0	682		var uri = new RawRequestUriBuilder();
	0	683		uri.Reset(endpoint);
	0	684		uri.AppendRawNextLink(nextLink, false);
	0	685		request.Uri = uri;
	0	686		return message;
		687		}
		688
		689		/// <summary>
		690		/// Retrieves all incoming relationship for a digital twin.
		691		/// Status codes:
		692		/// 200 (OK): Success.
		693		/// 400 (Bad Request): The request is invalid.
		694		/// 404 (Not Found): There is no digital twin with the provided id.
		695		/// </summary>
		696		/// <param name="nextLink"> The URL to the next page of results. </param>
		697		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		698		/// <param name="cancellationToken"> The cancellation token to use. </param>
		699		/// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> or <paramref name="id"/> is null. </exc
		700		public async Task<Response<IncomingRelationshipCollection>> ListIncomingRelationshipsNextPageAsync(string nextLi
		701		{
	0	702		if (nextLink == null)
		703		{
	0	704		throw new ArgumentNullException(nameof(nextLink));
		705		}
	0	706		if (id == null)
		707		{
	0	708		throw new ArgumentNullException(nameof(id));
		709		}
		710
	0	711		using var message = CreateListIncomingRelationshipsNextPageRequest(nextLink, id);
	0	712		await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
	0	713		switch (message.Response.Status)
		714		{
		715		case 200:
		716		{
		717		IncomingRelationshipCollection value = default;
	0	718		using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, canc
	0	719		value = IncomingRelationshipCollection.DeserializeIncomingRelationshipCollection(document.RootEl
	0	720		return Response.FromValue(value, message.Response);
		721		}
		722		default:
	0	723		throw await _clientDiagnostics.CreateRequestFailedExceptionAsync(message.Response).ConfigureAwait(fa
		724		}
	0	725		}
		726
		727		/// <summary>
		728		/// Retrieves all incoming relationship for a digital twin.
		729		/// Status codes:
		730		/// 200 (OK): Success.
		731		/// 400 (Bad Request): The request is invalid.
		732		/// 404 (Not Found): There is no digital twin with the provided id.
		733		/// </summary>
		734		/// <param name="nextLink"> The URL to the next page of results. </param>
		735		/// <param name="id"> The id of the digital twin. The id is unique within the service and case sensitive. </para
		736		/// <param name="cancellationToken"> The cancellation token to use. </param>
		737		/// <exception cref="ArgumentNullException"> <paramref name="nextLink"/> or <paramref name="id"/> is null. </exc
		738		public Response<IncomingRelationshipCollection> ListIncomingRelationshipsNextPage(string nextLink, string id, Ca
		739		{
	0	740		if (nextLink == null)
		741		{
	0	742		throw new ArgumentNullException(nameof(nextLink));
		743		}
	0	744		if (id == null)
		745		{
	0	746		throw new ArgumentNullException(nameof(id));
		747		}
		748
	0	749		using var message = CreateListIncomingRelationshipsNextPageRequest(nextLink, id);
	0	750		_pipeline.Send(message, cancellationToken);
	0	751		switch (message.Response.Status)
		752		{
		753		case 200:
		754		{
		755		IncomingRelationshipCollection value = default;
	0	756		using var document = JsonDocument.Parse(message.Response.ContentStream);
	0	757		value = IncomingRelationshipCollection.DeserializeIncomingRelationshipCollection(document.RootEl
	0	758		return Response.FromValue(value, message.Response);
		759		}
		760		default:
	0	761		throw _clientDiagnostics.CreateRequestFailedException(message.Response);
		762		}
	0	763		}
		764		}
		765		}