diff --git a/src/DiadocApi.Async.cs b/src/DiadocApi.Async.cs
index 982f877b..00bc6d91 100644
--- a/src/DiadocApi.Async.cs
+++ b/src/DiadocApi.Async.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Proto;
 using Diadoc.Api.Proto.Docflow;
@@ -27,423 +28,425 @@ namespace Diadoc.Api
 {
 	public partial class DiadocApi
 	{
-		public Task<string> AuthenticateAsync(string login, string password, string key = null, string id = null)
+		public Task<string> AuthenticateAsync(string login, string password, string key = null, string id = null, CancellationToken ct = default)
 		{
-			return diadocHttpApi.AuthenticateAsync(login, password, key, id);
+			return diadocHttpApi.AuthenticateAsync(login, password, key, id, ct: ct);
 		}
 
-		public Task<string> AuthenticateByKeyAsync([NotNull] string key, [NotNull] string id)
+		public Task<string> AuthenticateByKeyAsync([NotNull] string key, [NotNull] string id, CancellationToken ct = default)
 		{
 			if (key == null) throw new ArgumentNullException("key");
 			if (id == null) throw new ArgumentNullException("id");
-			return diadocHttpApi.AuthenticateByKeyAsync(key, id);
+			return diadocHttpApi.AuthenticateByKeyAsync(key, id, ct: ct);
 		}
 
-		public Task<string> AuthenticateBySidAsync([NotNull] string sid)
+		public Task<string> AuthenticateBySidAsync([NotNull] string sid, CancellationToken ct = default)
 		{
 			if (sid == null) throw new ArgumentNullException("sid");
-			return diadocHttpApi.AuthenticateBySidAsync(sid);
+			return diadocHttpApi.AuthenticateBySidAsync(sid, ct: ct);
 		}
 
-		public Task<string> AuthenticateAsync(byte[] certificateBytes, bool useLocalSystemStorage = false)
+		public Task<string> AuthenticateAsync(byte[] certificateBytes, bool useLocalSystemStorage = false, CancellationToken ct = default)
 		{
 			if (certificateBytes == null) throw new ArgumentNullException("certificateBytes");
-			return diadocHttpApi.AuthenticateAsync(certificateBytes, useLocalSystemStorage);
+			return diadocHttpApi.AuthenticateAsync(certificateBytes, useLocalSystemStorage, ct: ct);
 		}
 
-		public Task<string> AuthenticateAsync(string thumbprint, bool useLocalSystemStorage = false)
+		public Task<string> AuthenticateAsync(string thumbprint, bool useLocalSystemStorage = false, CancellationToken ct = default)
 		{
 			if (thumbprint == null) throw new ArgumentNullException("thumbprint");
-			return diadocHttpApi.AuthenticateAsync(thumbprint, useLocalSystemStorage);
+			return diadocHttpApi.AuthenticateAsync(thumbprint, useLocalSystemStorage, ct: ct);
 		}
 
-		public Task<string> AuthenticateWithKeyAsync(string thumbprint, bool useLocalSystemStorage = false, string key = null, string id = null, bool autoConfirm = true)
+		public Task<string> AuthenticateWithKeyAsync(string thumbprint, bool useLocalSystemStorage = false, string key = null, string id = null, bool autoConfirm = true, CancellationToken ct = default)
 		{
 			if (thumbprint == null) throw new ArgumentNullException("thumbprint");
-			return diadocHttpApi.AuthenticateWithKeyAsync(thumbprint, useLocalSystemStorage, key, id, autoConfirm);
+			return diadocHttpApi.AuthenticateWithKeyAsync(thumbprint, useLocalSystemStorage, key, id, autoConfirm, ct: ct);
 		}
 
-		public Task<string> AuthenticateWithKeyAsync(byte[] certificateBytes, bool useLocalSystemStorage = false, string key = null, string id = null, bool autoConfirm = true)
+		public Task<string> AuthenticateWithKeyAsync(byte[] certificateBytes, bool useLocalSystemStorage = false, string key = null, string id = null, bool autoConfirm = true, CancellationToken ct = default)
 		{
 			if (certificateBytes == null) throw new ArgumentNullException("certificateBytes");
-			return diadocHttpApi.AuthenticateWithKeyAsync(certificateBytes, useLocalSystemStorage, key, id, autoConfirm);
+			return diadocHttpApi.AuthenticateWithKeyAsync(certificateBytes, useLocalSystemStorage, key, id, autoConfirm, ct: ct);
 		}
 
-		public Task<string> AuthenticateWithKeyConfirmAsync(byte[] certificateBytes, string token, bool saveBinding = false)
+		public Task<string> AuthenticateWithKeyConfirmAsync(byte[] certificateBytes, string token, bool saveBinding = false, CancellationToken ct = default)
 		{
 			if (certificateBytes == null) throw new ArgumentNullException("certificateBytes");
 			if (string.IsNullOrEmpty(token)) throw new ArgumentNullException("token");
-			return diadocHttpApi.AuthenticateWithKeyConfirmAsync(certificateBytes, token, saveBinding);
+			return diadocHttpApi.AuthenticateWithKeyConfirmAsync(certificateBytes, token, saveBinding, ct: ct);
 		}
 
-		public Task<string> AuthenticateWithKeyConfirmAsync(string thumbprint, string token, bool saveBinding = false)
+		public Task<string> AuthenticateWithKeyConfirmAsync(string thumbprint, string token, bool saveBinding = false, CancellationToken ct = default)
 		{
 			if (thumbprint == null) throw new ArgumentNullException("thumbprint");
 			if (string.IsNullOrEmpty(token)) throw new ArgumentNullException("token");
-			return diadocHttpApi.AuthenticateWithKeyConfirmAsync(thumbprint, token, saveBinding);
+			return diadocHttpApi.AuthenticateWithKeyConfirmAsync(thumbprint, token, saveBinding, ct: ct);
 		}
 
-		public Task<OrganizationUserPermissions> GetMyPermissionsAsync(string authToken, string orgId)
+		public Task<OrganizationUserPermissions> GetMyPermissionsAsync(string authToken, string orgId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (orgId == null) throw new ArgumentNullException("orgId");
-			return diadocHttpApi.GetMyPermissionsAsync(authToken, orgId);
+			return diadocHttpApi.GetMyPermissionsAsync(authToken, orgId, ct: ct);
 		}
 
-		public Task<OrganizationList> GetMyOrganizationsAsync(string authToken, bool autoRegister = true)
+		public Task<OrganizationList> GetMyOrganizationsAsync(string authToken, bool autoRegister = true, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
-			return diadocHttpApi.GetMyOrganizationsAsync(authToken, autoRegister);
+			return diadocHttpApi.GetMyOrganizationsAsync(authToken, autoRegister, ct: ct);
 		}
 
-		public Task<User> GetMyUserAsync(string authToken)
+		public Task<User> GetMyUserAsync(string authToken, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
-			return diadocHttpApi.GetMyUserAsync(authToken);
+			return diadocHttpApi.GetMyUserAsync(authToken, ct: ct);
 		}
 
-		public Task<UserV2> GetMyUserV2Async(string authToken)
+		public Task<UserV2> GetMyUserV2Async(string authToken, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
-			return diadocHttpApi.GetMyUserV2Async(authToken);
+			return diadocHttpApi.GetMyUserV2Async(authToken, ct: ct);
 		}
 
-		public Task<UserV2> UpdateMyUserAsync(string authToken, UserToUpdate userToUpdate)
+		public Task<UserV2> UpdateMyUserAsync(string authToken, UserToUpdate userToUpdate, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (userToUpdate == null) throw new ArgumentNullException("userToUpdate");
-			return diadocHttpApi.UpdateMyUserAsync(authToken, userToUpdate);
+			return diadocHttpApi.UpdateMyUserAsync(authToken, userToUpdate, ct: ct);
 		}
 		
-		public Task<CertificateList> GetMyCertificatesAsync(string authToken, string boxId)
+		public Task<CertificateList> GetMyCertificatesAsync(string authToken, string boxId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetMyCertificatesAsync(authToken, boxId);
+			return diadocHttpApi.GetMyCertificatesAsync(authToken, boxId, ct: ct);
 		}
 
-		public Task<OrganizationList> GetOrganizationsByInnKppAsync(string inn, string kpp, bool includeRelations = false)
+		public Task<OrganizationList> GetOrganizationsByInnKppAsync(string inn, string kpp, bool includeRelations = false, CancellationToken ct = default)
 		{
 			if (inn == null) throw new ArgumentNullException("inn");
-			return diadocHttpApi.GetOrganizationsByInnKppAsync(inn, kpp, includeRelations);
+			return diadocHttpApi.GetOrganizationsByInnKppAsync(inn, kpp, includeRelations, ct: ct);
 		}
 
-		public Task<Organization> GetOrganizationByIdAsync(string orgId)
+		public Task<Organization> GetOrganizationByIdAsync(string orgId, CancellationToken ct = default)
 		{
 			if (orgId == null) throw new ArgumentNullException("orgId");
-			return diadocHttpApi.GetOrganizationByIdAsync(orgId);
+			return diadocHttpApi.GetOrganizationByIdAsync(orgId, ct: ct);
 		}
 
-		public Task<Organization> GetOrganizationByBoxIdAsync(string boxId)
+		public Task<Organization> GetOrganizationByBoxIdAsync(string boxId, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetOrganizationByBoxIdAsync(boxId);
+			return diadocHttpApi.GetOrganizationByBoxIdAsync(boxId, ct: ct);
 		}
 
-		public Task<Organization> GetOrganizationByFnsParticipantIdAsync(string fnsParticipantId)
+		public Task<Organization> GetOrganizationByFnsParticipantIdAsync(string fnsParticipantId, CancellationToken ct = default)
 		{
 			if (fnsParticipantId == null) throw new ArgumentException("fnsParticipantId");
-			return diadocHttpApi.GetOrganizationByFnsParticipantIdAsync(fnsParticipantId);
+			return diadocHttpApi.GetOrganizationByFnsParticipantIdAsync(fnsParticipantId, ct: ct);
 		}
 
-		public Task<Organization> GetOrganizationByInnKppAsync(string inn, string kpp)
+		public Task<Organization> GetOrganizationByInnKppAsync(string inn, string kpp, CancellationToken ct = default)
 		{
 			if (inn == null) throw new ArgumentException("inn");
-			return diadocHttpApi.GetOrganizationByInnKppAsync(inn, kpp);
+			return diadocHttpApi.GetOrganizationByInnKppAsync(inn, kpp, ct: ct);
 		}
 
-		public Task<Box> GetBoxAsync(string boxId)
+		public Task<Box> GetBoxAsync(string boxId, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetBoxAsync(boxId);
+			return diadocHttpApi.GetBoxAsync(boxId, ct: ct);
 		}
 
-		public Task<Department> GetDepartmentAsync(string authToken, string orgId, string departmentId)
+		public Task<Department> GetDepartmentAsync(string authToken, string orgId, string departmentId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (orgId == null) throw new ArgumentNullException("orgId");
 			if (departmentId == null) throw new ArgumentNullException("departmentId");
-			return diadocHttpApi.GetDepartmentAsync(authToken, orgId, departmentId);
+			return diadocHttpApi.GetDepartmentAsync(authToken, orgId, departmentId, ct: ct);
 		}
 
-		public Task UpdateOrganizationPropertiesAsync(string authToken, OrganizationPropertiesToUpdate orgProps)
+		public Task UpdateOrganizationPropertiesAsync(string authToken, OrganizationPropertiesToUpdate orgProps, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (orgProps == null) throw new ArgumentNullException("orgProps");
-			return diadocHttpApi.UpdateOrganizationPropertiesAsync(authToken, orgProps);
+			return diadocHttpApi.UpdateOrganizationPropertiesAsync(authToken, orgProps, ct: ct);
 		}
 
-		public Task<OrganizationFeatures> GetOrganizationFeaturesAsync(string authToken, string boxId)
+		public Task<OrganizationFeatures> GetOrganizationFeaturesAsync(string authToken, string boxId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetOrganizationFeaturesAsync(authToken, boxId);
+			return diadocHttpApi.GetOrganizationFeaturesAsync(authToken, boxId, ct: ct);
 		}
 
-		public Task<BoxEventList> GetNewEventsAsync(string authToken, string boxId, string afterEventId = null)
+		public Task<BoxEventList> GetNewEventsAsync(string authToken, string boxId, string afterEventId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetNewEventsAsync(authToken, boxId, afterEventId);
+			return diadocHttpApi.GetNewEventsAsync(authToken, boxId, afterEventId, ct: ct);
 		}
 
-		public Task<BoxEvent> GetEventAsync(string authToken, string boxId, string eventId)
+		public Task<BoxEvent> GetEventAsync(string authToken, string boxId, string eventId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (eventId == null) throw new ArgumentNullException("eventId");
-			return diadocHttpApi.GetEventAsync(authToken, boxId, eventId);
+			return diadocHttpApi.GetEventAsync(authToken, boxId, eventId, ct: ct);
 		}
 
-		public Task<Message> PostMessageAsync(string authToken, MessageToPost msg, string operationId = null)
+		public Task<Message> PostMessageAsync(string authToken, MessageToPost msg, string operationId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (msg == null) throw new ArgumentNullException("msg");
-			return diadocHttpApi.PostMessageAsync(authToken, msg, operationId);
+			return diadocHttpApi.PostMessageAsync(authToken, msg, operationId, ct: ct);
 		}
 
-		public Task<Template> PostTemplateAsync(string authToken, TemplateToPost template, string operationId = null)
+		public Task<Template> PostTemplateAsync(string authToken, TemplateToPost template, string operationId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (template == null) throw new ArgumentNullException("template");
-			return diadocHttpApi.PostTemplateAsync(authToken, template, operationId);
+			return diadocHttpApi.PostTemplateAsync(authToken, template, operationId, ct: ct);
 		}
 
-		public Task<Message> TransformTemplateToMessageAsync(string authToken, TemplateTransformationToPost templateTransformation, string operationId = null)
+		public Task<Message> TransformTemplateToMessageAsync(string authToken, TemplateTransformationToPost templateTransformation, string operationId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (templateTransformation == null) throw new ArgumentNullException("templateTransformation");
-			return diadocHttpApi.TransformTemplateToMessageAsync(authToken, templateTransformation, operationId);
+			return diadocHttpApi.TransformTemplateToMessageAsync(authToken, templateTransformation, operationId, ct: ct);
 		}
 
-		public Task<MessagePatch> PostMessagePatchAsync(string authToken, MessagePatchToPost patch, string operationId = null)
+		public Task<MessagePatch> PostMessagePatchAsync(string authToken, MessagePatchToPost patch, string operationId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (patch == null) throw new ArgumentNullException("patch");
-			return diadocHttpApi.PostMessagePatchAsync(authToken, patch, operationId);
+			return diadocHttpApi.PostMessagePatchAsync(authToken, patch, operationId, ct: ct);
 		}
 
-		public Task<MessagePatch> PostTemplatePatchAsync(string authToken, string boxId, string templateId, TemplatePatchToPost patch, string operationId = null)
+		public Task<MessagePatch> PostTemplatePatchAsync(string authToken, string boxId, string templateId, TemplatePatchToPost patch, string operationId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (templateId == null) throw new ArgumentNullException("templateId");
 			if (patch == null) throw new ArgumentNullException("patch");
-			return diadocHttpApi.PostTemplatePatchAsync(authToken, boxId, templateId, patch, operationId);
+			return diadocHttpApi.PostTemplatePatchAsync(authToken, boxId, templateId, patch, operationId, ct: ct);
 		}
 
-		public Task PostRoamingNotificationAsync(string authToken, RoamingNotificationToPost notification)
+		public Task PostRoamingNotificationAsync(string authToken, RoamingNotificationToPost notification, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (notification == null) throw new ArgumentNullException("notification");
-			return diadocHttpApi.PostRoamingNotificationAsync(authToken, notification);
+			return diadocHttpApi.PostRoamingNotificationAsync(authToken, notification, ct: ct);
 		}
 
-		public Task DeleteAsync(string authToken, string boxId, string messageId, string documentId)
+		public Task DeleteAsync(string authToken, string boxId, string messageId, string documentId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
-			return diadocHttpApi.DeleteAsync(authToken, boxId, messageId, documentId);
+			return diadocHttpApi.DeleteAsync(authToken, boxId, messageId, documentId, ct: ct);
 		}
 
-		public Task RestoreAsync(string authToken, string boxId, string messageId, string documentId)
+		public Task RestoreAsync(string authToken, string boxId, string messageId, string documentId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
-			return diadocHttpApi.RestoreAsync(authToken, boxId, messageId, documentId);
+			return diadocHttpApi.RestoreAsync(authToken, boxId, messageId, documentId, ct: ct);
 		}
 
-		public Task MoveDocumentsAsync(string authToken, DocumentsMoveOperation query)
+		public Task MoveDocumentsAsync(string authToken, DocumentsMoveOperation query, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (query == null) throw new ArgumentNullException("query");
-			return diadocHttpApi.MoveDocumentsAsync(authToken, query);
+			return diadocHttpApi.MoveDocumentsAsync(authToken, query, ct: ct);
 		}
 
-		public Task<byte[]> GetEntityContentAsync(string authToken, string boxId, string messageId, string entityId)
+		public Task<byte[]> GetEntityContentAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (entityId == null) throw new ArgumentNullException("entityId");
-			return diadocHttpApi.GetEntityContentAsync(authToken, boxId, messageId, entityId);
+			return diadocHttpApi.GetEntityContentAsync(authToken, boxId, messageId, entityId, ct: ct);
 		}
 
 		[Obsolete("Use GenerateReceiptXmlAsync()")]
-		public Task<GeneratedFile> GenerateDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer)
+		public Task<GeneratedFile> GenerateDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (attachmentId == null) throw new ArgumentNullException("attachmentId");
 			if (signer == null) throw new ArgumentNullException("signer");
-			return diadocHttpApi.GenerateReceiptXmlAsync(authToken, boxId, messageId, attachmentId, signer);
+			return diadocHttpApi.GenerateReceiptXmlAsync(authToken, boxId, messageId, attachmentId, signer, ct: ct);
 		}
 
 		[Obsolete("Use GenerateReceiptXmlAsync()")]
-		public Task<GeneratedFile> GenerateInvoiceDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer)
+		public Task<GeneratedFile> GenerateInvoiceDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (attachmentId == null) throw new ArgumentNullException("attachmentId");
 			if (signer == null) throw new ArgumentNullException("signer");
-			return diadocHttpApi.GenerateReceiptXmlAsync(authToken, boxId, messageId, attachmentId, signer);
+			return diadocHttpApi.GenerateReceiptXmlAsync(authToken, boxId, messageId, attachmentId, signer, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer)
+		public Task<GeneratedFile> GenerateReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (attachmentId == null) throw new ArgumentNullException("attachmentId");
 			if (signer == null) throw new ArgumentNullException("signer");
-			return diadocHttpApi.GenerateReceiptXmlAsync(authToken, boxId, messageId, attachmentId, signer);
+			return diadocHttpApi.GenerateReceiptXmlAsync(authToken, boxId, messageId, attachmentId, signer, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateInvoiceCorrectionRequestXmlAsync(string authToken, string boxId, string messageId,
-			string attachmentId, InvoiceCorrectionRequestInfo correctionInfo)
+			string attachmentId, InvoiceCorrectionRequestInfo correctionInfo, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (attachmentId == null) throw new ArgumentNullException("attachmentId");
-			return diadocHttpApi.GenerateInvoiceCorrectionRequestXmlAsync(authToken, boxId, messageId, attachmentId, correctionInfo);
+			return diadocHttpApi.GenerateInvoiceCorrectionRequestXmlAsync(authToken, boxId, messageId, attachmentId, correctionInfo, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateRevocationRequestXmlAsync(string authToken, string boxId, string messageId,
-			string attachmentId, RevocationRequestInfo revocationRequestInfo)
+			string attachmentId, RevocationRequestInfo revocationRequestInfo, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (attachmentId == null) throw new ArgumentNullException("attachmentId");
-			return diadocHttpApi.GenerateRevocationRequestXmlAsync(authToken, boxId, messageId, attachmentId, revocationRequestInfo);
+			return diadocHttpApi.GenerateRevocationRequestXmlAsync(authToken, boxId, messageId, attachmentId, revocationRequestInfo, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateSignatureRejectionXmlAsync(string authToken, string boxId, string messageId,
-			string attachmentId, SignatureRejectionInfo signatureRejectionInfo)
+			string attachmentId, SignatureRejectionInfo signatureRejectionInfo, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (attachmentId == null) throw new ArgumentNullException("attachmentId");
-			return diadocHttpApi.GenerateSignatureRejectionXmlAsync(authToken, boxId, messageId, attachmentId, signatureRejectionInfo);
+			return diadocHttpApi.GenerateSignatureRejectionXmlAsync(authToken, boxId, messageId, attachmentId, signatureRejectionInfo, ct: ct);
 		}
 
 		public Task<InvoiceCorrectionRequestInfo> GetInvoiceCorrectionRequestInfoAsync(string authToken, string boxId, string messageId,
-			string entityId)
+			string entityId, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (entityId == null) throw new ArgumentNullException("entityId");
-			return diadocHttpApi.GetInvoiceCorrectionRequestInfoAsync(authToken, boxId, messageId, entityId);
+			return diadocHttpApi.GetInvoiceCorrectionRequestInfoAsync(authToken, boxId, messageId, entityId, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateInvoiceXmlAsync(string authToken, InvoiceInfo invoiceInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateInvoiceXmlAsync(string authToken, InvoiceInfo invoiceInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
 			if (invoiceInfo == null) throw new ArgumentNullException("invoiceInfo");
-			return diadocHttpApi.GenerateInvoiceXmlAsync(authToken, invoiceInfo, disableValidation);
+			return diadocHttpApi.GenerateInvoiceXmlAsync(authToken, invoiceInfo, disableValidation, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateInvoiceRevisionXmlAsync(string authToken, InvoiceInfo invoiceRevisionInfo,
-			bool disableValidation = false)
+			bool disableValidation = false, CancellationToken ct = default)
 		{
 			if (invoiceRevisionInfo == null) throw new ArgumentNullException("invoiceRevisionInfo");
-			return diadocHttpApi.GenerateInvoiceRevisionXmlAsync(authToken, invoiceRevisionInfo, disableValidation);
+			return diadocHttpApi.GenerateInvoiceRevisionXmlAsync(authToken, invoiceRevisionInfo, disableValidation, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateInvoiceCorrectionXmlAsync(string authToken, InvoiceCorrectionInfo invoiceCorrectionInfo,
-			bool disableValidation = false)
+			bool disableValidation = false, CancellationToken ct = default)
 		{
 			if (invoiceCorrectionInfo == null) throw new ArgumentNullException("invoiceCorrectionInfo");
-			return diadocHttpApi.GenerateInvoiceCorrectionXmlAsync(authToken, invoiceCorrectionInfo, disableValidation);
+			return diadocHttpApi.GenerateInvoiceCorrectionXmlAsync(authToken, invoiceCorrectionInfo, disableValidation, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateInvoiceCorrectionRevisionXmlAsync(string authToken,
-			InvoiceCorrectionInfo invoiceCorrectionRevision, bool disableValidation = false)
+			InvoiceCorrectionInfo invoiceCorrectionRevision, bool disableValidation = false, CancellationToken ct = default)
 		{
 			if (invoiceCorrectionRevision == null) throw new ArgumentNullException("invoiceCorrectionRevision");
-			return diadocHttpApi.GenerateInvoiceCorrectionRevisionXmlAsync(authToken, invoiceCorrectionRevision, disableValidation);
+			return diadocHttpApi.GenerateInvoiceCorrectionRevisionXmlAsync(authToken, invoiceCorrectionRevision, disableValidation, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateTorg12XmlForSellerAsync(string authToken, Torg12SellerTitleInfo sellerInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateTorg12XmlForSellerAsync(string authToken, Torg12SellerTitleInfo sellerInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
 			if (sellerInfo == null) throw new ArgumentNullException("sellerInfo");
-			return diadocHttpApi.GenerateTorg12XmlForSellerAsync(authToken, sellerInfo, disableValidation);
+			return diadocHttpApi.GenerateTorg12XmlForSellerAsync(authToken, sellerInfo, disableValidation, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateTovTorg551XmlForSellerAsync(string authToken, TovTorgSellerTitleInfo sellerInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateTovTorg551XmlForSellerAsync(string authToken, TovTorgSellerTitleInfo sellerInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
 			if (sellerInfo == null) throw new ArgumentNullException("sellerInfo");
-			return diadocHttpApi.GenerateTovTorg551XmlForSellerAsync(authToken, sellerInfo, disableValidation);
+			return diadocHttpApi.GenerateTovTorg551XmlForSellerAsync(authToken, sellerInfo, disableValidation, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateTorg12XmlForBuyerAsync(string authToken, Torg12BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId)
+		public Task<GeneratedFile> GenerateTorg12XmlForBuyerAsync(string authToken, Torg12BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default)
 		{
 			if (buyerInfo == null) throw new ArgumentNullException("buyerInfo");
-			return diadocHttpApi.GenerateTorg12XmlForBuyerAsync(authToken, buyerInfo, boxId, sellerTitleMessageId, sellerTitleAttachmentId);
+			return diadocHttpApi.GenerateTorg12XmlForBuyerAsync(authToken, buyerInfo, boxId, sellerTitleMessageId, sellerTitleAttachmentId, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateTovTorg551XmlForBuyerAsync(string authToken, TovTorgBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, string documentVersion = null)
+		public Task<GeneratedFile> GenerateTovTorg551XmlForBuyerAsync(string authToken, TovTorgBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, string documentVersion = null, CancellationToken ct = default)
 		{
 			if (buyerInfo == null) throw new ArgumentNullException("buyerInfo");
-			return diadocHttpApi.GenerateTovTorg551XmlForBuyerAsync(authToken, buyerInfo, boxId, sellerTitleMessageId, sellerTitleAttachmentId, documentVersion);
+			return diadocHttpApi.GenerateTovTorg551XmlForBuyerAsync(authToken, buyerInfo, boxId, sellerTitleMessageId, sellerTitleAttachmentId, documentVersion, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateAcceptanceCertificateXmlForSellerAsync(string authToken,
-			AcceptanceCertificateSellerTitleInfo sellerInfo, bool disableValidation = false)
+			AcceptanceCertificateSellerTitleInfo sellerInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
 			if (sellerInfo == null) throw new ArgumentNullException("sellerInfo");
-			return diadocHttpApi.GenerateAcceptanceCertificateXmlForSellerAsync(authToken, sellerInfo, disableValidation);
+			return diadocHttpApi.GenerateAcceptanceCertificateXmlForSellerAsync(authToken, sellerInfo, disableValidation, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateAcceptanceCertificateXmlForBuyerAsync(string authToken,
 			AcceptanceCertificateBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId,
-			string sellerTitleAttachmentId)
+			string sellerTitleAttachmentId, CancellationToken ct = default)
 		{
 			if (buyerInfo == null) throw new ArgumentNullException("buyerInfo");
 			return diadocHttpApi.GenerateAcceptanceCertificateXmlForBuyerAsync(authToken, buyerInfo, boxId, sellerTitleMessageId,
-				sellerTitleAttachmentId);
+				sellerTitleAttachmentId, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForSellerAsync(string authToken, AcceptanceCertificate552SellerTitleInfo sellerInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForSellerAsync(string authToken, AcceptanceCertificate552SellerTitleInfo sellerInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
 			if (sellerInfo == null) throw new ArgumentNullException("sellerInfo");
-			return diadocHttpApi.GenerateAcceptanceCertificate552XmlForSellerAsync(authToken, sellerInfo, disableValidation);
+			return diadocHttpApi.GenerateAcceptanceCertificate552XmlForSellerAsync(authToken, sellerInfo, disableValidation, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForBuyerAsync(string authToken, AcceptanceCertificate552BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId)
+		public Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForBuyerAsync(string authToken, AcceptanceCertificate552BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default)
 		{
 			if (buyerInfo == null) throw new ArgumentNullException("buyerInfo");
 			return diadocHttpApi.GenerateAcceptanceCertificate552XmlForBuyerAsync(authToken, buyerInfo, boxId, sellerTitleMessageId,
-				sellerTitleAttachmentId);
+				sellerTitleAttachmentId, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateUniversalTransferDocumentXmlForSellerAsync(
 			string authToken,
 			UniversalTransferDocumentSellerTitleInfo sellerInfo,
 			bool disableValidation = false,
-			string documentVersion = null)
+			string documentVersion = null, 
+			CancellationToken ct = default)
 		{
 			if (sellerInfo == null) throw new ArgumentNullException("sellerInfo");
-			return diadocHttpApi.GenerateUniversalTransferDocumentXmlForSellerAsync(authToken, sellerInfo, disableValidation, documentVersion);
+			return diadocHttpApi.GenerateUniversalTransferDocumentXmlForSellerAsync(authToken, sellerInfo, disableValidation, documentVersion, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateUniversalCorrectionDocumentXmlForSellerAsync(
 			string authToken,
 			UniversalCorrectionDocumentSellerTitleInfo sellerInfo,
 			bool disableValidation = false,
-			string documentVersion = null)
+			string documentVersion = null,
+			CancellationToken ct = default)
 		{
 			if (sellerInfo == null) throw new ArgumentNullException("sellerInfo");
-			return diadocHttpApi.GenerateUniversalCorrectionDocumentXmlForSellerAsync(authToken, sellerInfo, disableValidation, documentVersion);
+			return diadocHttpApi.GenerateUniversalCorrectionDocumentXmlForSellerAsync(authToken, sellerInfo, disableValidation, documentVersion, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateUniversalTransferDocumentXmlForBuyerAsync(string authToken, UniversalTransferDocumentBuyerTitleInfo buyerInfo,
-			string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId)
+			string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default)
 		{
 			if (buyerInfo == null) throw new ArgumentNullException("buyerInfo");
-			return diadocHttpApi.GenerateUniversalTransferDocumentXmlForBuyerAsync(authToken, buyerInfo, boxId, sellerTitleMessageId, sellerTitleAttachmentId);
+			return diadocHttpApi.GenerateUniversalTransferDocumentXmlForBuyerAsync(authToken, buyerInfo, boxId, sellerTitleMessageId, sellerTitleAttachmentId, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateTitleXmlAsync(string authToken, string boxId, string documentTypeNamedId, string documentFunction, string documentVersion, int titleIndex, byte[] userContractData, bool disableValidation = false, string editingSettingId = null, string letterId = null, string documentId = null)
+		public Task<GeneratedFile> GenerateTitleXmlAsync(string authToken, string boxId, string documentTypeNamedId, string documentFunction, string documentVersion, int titleIndex, byte[] userContractData, bool disableValidation = false, string editingSettingId = null, string letterId = null, string documentId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
@@ -463,10 +466,11 @@ public Task<GeneratedFile> GenerateTitleXmlAsync(string authToken, string boxId,
 				disableValidation,
 				editingSettingId,
 				letterId,
-				documentId);
+				documentId, 
+				ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateSenderTitleXmlAsync(string authToken, string boxId, string documentTypeNamedId, string documentFunction, string documentVersion, byte[] userContractData, bool disableValidation = false, string editingSettingId = null)
+		public Task<GeneratedFile> GenerateSenderTitleXmlAsync(string authToken, string boxId, string documentTypeNamedId, string documentFunction, string documentVersion, byte[] userContractData, bool disableValidation = false, string editingSettingId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
@@ -474,329 +478,329 @@ public Task<GeneratedFile> GenerateSenderTitleXmlAsync(string authToken, string
 			if (documentFunction == null) throw new ArgumentNullException("documentFunction");
 			if (documentVersion == null) throw new ArgumentNullException("documentVersion");
 			if (userContractData == null) throw new ArgumentNullException("userContractData");
-			return diadocHttpApi.GenerateSenderTitleXmlAsync(authToken, boxId, documentTypeNamedId, documentFunction, documentVersion, userContractData, disableValidation, editingSettingId);
+			return diadocHttpApi.GenerateSenderTitleXmlAsync(authToken, boxId, documentTypeNamedId, documentFunction, documentVersion, userContractData, disableValidation, editingSettingId, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateRecipientTitleXmlAsync(string authToken, string boxId, string senderTitleMessageId, string senderTitleAttachmentId, byte[] userContractData, string documentVersion = null)
+		public Task<GeneratedFile> GenerateRecipientTitleXmlAsync(string authToken, string boxId, string senderTitleMessageId, string senderTitleAttachmentId, byte[] userContractData, string documentVersion = null, CancellationToken ct = default)
 		{
 			if (userContractData == null) throw new ArgumentNullException("userContractData");
 			if (senderTitleMessageId == null) throw new ArgumentNullException("senderTitleMessageId");
 			if (senderTitleAttachmentId == null) throw new ArgumentNullException("senderTitleAttachmentId");
-			return diadocHttpApi.GenerateRecipientTitleXmlAsync(authToken, boxId, senderTitleMessageId, senderTitleAttachmentId, userContractData);
+			return diadocHttpApi.GenerateRecipientTitleXmlAsync(authToken, boxId, senderTitleMessageId, senderTitleAttachmentId, userContractData, ct: ct);
 		}
 
-		public Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, bool withOriginalSignature = false, bool injectEntityContent = false)
+		public Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, bool withOriginalSignature = false, bool injectEntityContent = false, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
-			return diadocHttpApi.GetMessageAsync(authToken, boxId, messageId, withOriginalSignature, injectEntityContent);
+			return diadocHttpApi.GetMessageAsync(authToken, boxId, messageId, withOriginalSignature, injectEntityContent, ct: ct);
 		}
 
-		public Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, string entityId, bool withOriginalSignature = false, bool injectEntityContent = false)
+		public Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, string entityId, bool withOriginalSignature = false, bool injectEntityContent = false, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (entityId == null) throw new ArgumentNullException("entityId");
-			return diadocHttpApi.GetMessageAsync(authToken, boxId, messageId, entityId, withOriginalSignature, injectEntityContent);
+			return diadocHttpApi.GetMessageAsync(authToken, boxId, messageId, entityId, withOriginalSignature, injectEntityContent, ct: ct);
 		}
 
-		public Task<Template> GetTemplateAsync(string authToken, string boxId, string templateId, string entityId = null)
+		public Task<Template> GetTemplateAsync(string authToken, string boxId, string templateId, string entityId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (templateId == null) throw new ArgumentNullException("templateId");
-			return diadocHttpApi.GetTemplateAsync(authToken, boxId, templateId, entityId);
+			return diadocHttpApi.GetTemplateAsync(authToken, boxId, templateId, entityId, ct: ct);
 		}
 
-		public Task RecycleDraftAsync(string authToken, string boxId, string draftId)
+		public Task RecycleDraftAsync(string authToken, string boxId, string draftId, CancellationToken ct = default)
 		{
-			return diadocHttpApi.RecycleDraftAsync(authToken, boxId, draftId);
+			return diadocHttpApi.RecycleDraftAsync(authToken, boxId, draftId, ct: ct);
 		}
 
-		public Task<Message> SendDraftAsync(string authToken, DraftToSend draftToSend, string operationId = null)
+		public Task<Message> SendDraftAsync(string authToken, DraftToSend draftToSend, string operationId = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (draftToSend == null) throw new ArgumentNullException("draftToSend");
-			return diadocHttpApi.SendDraftAsync(authToken, draftToSend, operationId);
+			return diadocHttpApi.SendDraftAsync(authToken, draftToSend, operationId, ct: ct);
 		}
 
-		public Task<PrintFormResult> GeneratePrintFormAsync(string authToken, string boxId, string messageId, string documentId)
+		public Task<PrintFormResult> GeneratePrintFormAsync(string authToken, string boxId, string messageId, string documentId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
 			if (string.IsNullOrEmpty(messageId)) throw new ArgumentNullException("messageId");
 			if (string.IsNullOrEmpty(documentId)) throw new ArgumentNullException("documentId");
-			return diadocHttpApi.GeneratePrintFormAsync(authToken, boxId, messageId, documentId);
+			return diadocHttpApi.GeneratePrintFormAsync(authToken, boxId, messageId, documentId, ct: ct);
 		}
 
 		public Task<string> GeneratePrintFormFromAttachmentAsync(string authToken, DocumentType documentType, byte[] content,
-			string fromBoxId = null)
+			string fromBoxId = null, CancellationToken ct = default)
 		{
-			return diadocHttpApi.GeneratePrintFormFromAttachmentAsync(authToken, documentType, content, fromBoxId);
+			return diadocHttpApi.GeneratePrintFormFromAttachmentAsync(authToken, documentType, content, fromBoxId, ct: ct);
 		}
 
 		[Obsolete("Use GetGeneratedPrintFormAsync without `documentType` parameter")]
-		public Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, DocumentType documentType, string printFormId)
+		public Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, DocumentType documentType, string printFormId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(printFormId)) throw new ArgumentNullException("printFormId");
-			return diadocHttpApi.GetGeneratedPrintFormAsync(authToken, documentType, printFormId);
+			return diadocHttpApi.GetGeneratedPrintFormAsync(authToken, documentType, printFormId, ct: ct);
 		}
 
-		public Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, string printFormId)
+		public Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, string printFormId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(printFormId)) throw new ArgumentNullException("printFormId");
-			return diadocHttpApi.GetGeneratedPrintFormAsync(authToken, printFormId);
+			return diadocHttpApi.GetGeneratedPrintFormAsync(authToken, printFormId, ct: ct);
 		}
 
-		public Task<string> RecognizeAsync(string fileName, byte[] content)
+		public Task<string> RecognizeAsync(string fileName, byte[] content, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(fileName)) throw new ArgumentNullException("fileName");
-			return diadocHttpApi.RecognizeAsync(fileName, content);
+			return diadocHttpApi.RecognizeAsync(fileName, content, ct: ct);
 		}
 
-		public Task<Recognized> GetRecognizedAsync(string recognitionId)
+		public Task<Recognized> GetRecognizedAsync(string recognitionId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(recognitionId)) throw new ArgumentNullException("recognitionId");
-			return diadocHttpApi.GetRecognizedAsync(recognitionId);
+			return diadocHttpApi.GetRecognizedAsync(recognitionId, ct: ct);
 		}
 
 		public Task<DocumentList> GetDocumentsAsync(string authToken, string boxId, string filterCategory, string counteragentBoxId,
 			DateTime? timestampFrom, DateTime? timestampTo, string fromDocumentDate, string toDocumentDate, string departmentId,
-			bool excludeSubdepartments, string afterIndexKey, int? count = null)
+			bool excludeSubdepartments, string afterIndexKey, int? count = null, CancellationToken ct = default)
 		{
 			return diadocHttpApi.GetDocumentsAsync(authToken, boxId, filterCategory, counteragentBoxId, timestampFrom, timestampTo,
-				fromDocumentDate, toDocumentDate, departmentId, excludeSubdepartments, afterIndexKey, count);
+				fromDocumentDate, toDocumentDate, departmentId, excludeSubdepartments, afterIndexKey, count, ct: ct);
 		}
 
-		public Task<DocumentList> GetDocumentsAsync(string authToken, DocumentsFilter filter)
+		public Task<DocumentList> GetDocumentsAsync(string authToken, DocumentsFilter filter, CancellationToken ct = default)
 		{
-			return diadocHttpApi.GetDocumentsAsync(authToken, filter);
+			return diadocHttpApi.GetDocumentsAsync(authToken, filter, ct: ct);
 		}
 
-		public Task<Document> GetDocumentAsync(string authToken, string boxId, string messageId, string entityId)
+		public Task<Document> GetDocumentAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default)
 		{
-			return diadocHttpApi.GetDocumentAsync(authToken, boxId, messageId, entityId);
+			return diadocHttpApi.GetDocumentAsync(authToken, boxId, messageId, entityId, ct: ct);
 		}
 
-		public Task<SignatureInfo> GetSignatureInfoAsync(string authToken, string boxId, string messageId, string entityId)
+		public Task<SignatureInfo> GetSignatureInfoAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default)
 		{
-			return diadocHttpApi.GetSignatureInfoAsync(authToken, boxId, messageId, entityId);
+			return diadocHttpApi.GetSignatureInfoAsync(authToken, boxId, messageId, entityId, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType)
+		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType, CancellationToken ct = default)
 		{
-			return diadocHttpApi.GetExtendedSignerDetailsAsync(token, boxId, thumbprint, documentTitleType);
+			return diadocHttpApi.GetExtendedSignerDetailsAsync(token, boxId, thumbprint, documentTitleType, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType)
+		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType, CancellationToken ct = default)
 		{
-			return diadocHttpApi.GetExtendedSignerDetailsAsync(token, boxId, certificateBytes, documentTitleType);
+			return diadocHttpApi.GetExtendedSignerDetailsAsync(token, boxId, certificateBytes, documentTitleType, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails)
+		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default)
 		{
-			return diadocHttpApi.PostExtendedSignerDetailsAsync(token, boxId, thumbprint, documentTitleType, signerDetails);
+			return diadocHttpApi.PostExtendedSignerDetailsAsync(token, boxId, thumbprint, documentTitleType, signerDetails, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails)
+		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default)
 		{
-			return diadocHttpApi.PostExtendedSignerDetailsAsync(token, boxId, certificateBytes, documentTitleType, signerDetails);
+			return diadocHttpApi.PostExtendedSignerDetailsAsync(token, boxId, certificateBytes, documentTitleType, signerDetails, ct: ct);
 		}
 
-		public Task<GetDocflowBatchResponse> GetDocflowsAsync(string authToken, string boxId, GetDocflowBatchRequest request)
+		public Task<GetDocflowBatchResponse> GetDocflowsAsync(string authToken, string boxId, GetDocflowBatchRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetDocflowsAsync(authToken, boxId, request);
+			return diadocHttpApi.GetDocflowsAsync(authToken, boxId, request, ct: ct);
 		}
 
-		public Task<GetDocflowEventsResponse> GetDocflowEventsAsync(string authToken, string boxId, GetDocflowEventsRequest request)
+		public Task<GetDocflowEventsResponse> GetDocflowEventsAsync(string authToken, string boxId, GetDocflowEventsRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetDocflowEventsAsync(authToken, boxId, request);
+			return diadocHttpApi.GetDocflowEventsAsync(authToken, boxId, request, ct: ct);
 		}
 
-		public Task<SearchDocflowsResponse> SearchDocflowsAsync(string authToken, string boxId, SearchDocflowsRequest request)
+		public Task<SearchDocflowsResponse> SearchDocflowsAsync(string authToken, string boxId, SearchDocflowsRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.SearchDocflowsAsync(authToken, boxId, request);
+			return diadocHttpApi.SearchDocflowsAsync(authToken, boxId, request, ct: ct);
 		}
 
 		public Task<GetDocflowsByPacketIdResponse> GetDocflowsByPacketIdAsync(string authToken, string boxId,
-			GetDocflowsByPacketIdRequest request)
+			GetDocflowsByPacketIdRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetDocflowsByPacketIdAsync(authToken, boxId, request);
+			return diadocHttpApi.GetDocflowsByPacketIdAsync(authToken, boxId, request, ct: ct);
 		}
 
-		public Task<ForwardDocumentResponse> ForwardDocumentAsync(string authToken, string boxId, ForwardDocumentRequest request)
+		public Task<ForwardDocumentResponse> ForwardDocumentAsync(string authToken, string boxId, ForwardDocumentRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.ForwardDocumentAsync(authToken, boxId, request);
+			return diadocHttpApi.ForwardDocumentAsync(authToken, boxId, request, ct: ct);
 		}
 
 		public Task<GetForwardedDocumentsResponse> GetForwardedDocumentsAsync(string authToken, string boxId,
-			GetForwardedDocumentsRequest request)
+			GetForwardedDocumentsRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetForwardedDocumentsAsync(authToken, boxId, request);
+			return diadocHttpApi.GetForwardedDocumentsAsync(authToken, boxId, request, ct: ct);
 		}
 
 		public Task<GetForwardedDocumentEventsResponse> GetForwardedDocumentEventsAsync(string authToken, string boxId,
-			GetForwardedDocumentEventsRequest request)
+			GetForwardedDocumentEventsRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetForwardedDocumentEventsAsync(authToken, boxId, request);
+			return diadocHttpApi.GetForwardedDocumentEventsAsync(authToken, boxId, request, ct: ct);
 		}
 
 		public Task<byte[]> GetForwardedEntityContentAsync(string authToken, string boxId, ForwardedDocumentId forwardedDocumentId,
-			string entityId)
+			string entityId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetForwardedEntityContentAsync(authToken, boxId, forwardedDocumentId, entityId);
+			return diadocHttpApi.GetForwardedEntityContentAsync(authToken, boxId, forwardedDocumentId, entityId, ct: ct);
 		}
 
 		public Task<DocumentProtocolResult> GenerateForwardedDocumentProtocolAsync(string authToken, string boxId,
-			ForwardedDocumentId forwardedDocumentId)
+			ForwardedDocumentId forwardedDocumentId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GenerateForwardedDocumentProtocolAsync(authToken, boxId, forwardedDocumentId);
+			return diadocHttpApi.GenerateForwardedDocumentProtocolAsync(authToken, boxId, forwardedDocumentId, ct: ct);
 		}
 
-		public Task<PrintFormResult> GenerateForwardedDocumentPrintFormAsync(string authToken, string boxId, ForwardedDocumentId forwardedDocumentId)
+		public Task<PrintFormResult> GenerateForwardedDocumentPrintFormAsync(string authToken, string boxId, ForwardedDocumentId forwardedDocumentId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GenerateForwardedDocumentPrintFormAsync(authToken, boxId, forwardedDocumentId);
+			return diadocHttpApi.GenerateForwardedDocumentPrintFormAsync(authToken, boxId, forwardedDocumentId, ct: ct);
 		}
 
-		public Task<bool> CanSendInvoiceAsync(string authToken, string boxId, byte[] certificateBytes)
+		public Task<bool> CanSendInvoiceAsync(string authToken, string boxId, byte[] certificateBytes, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
 			if (certificateBytes == null || certificateBytes.Length == 0) throw new ArgumentNullException("certificateBytes");
-			return diadocHttpApi.CanSendInvoiceAsync(authToken, boxId, certificateBytes);
+			return diadocHttpApi.CanSendInvoiceAsync(authToken, boxId, certificateBytes, ct: ct);
 		}
 
 		public Task SendFnsRegistrationMessageAsync(string authToken, string boxId,
-			FnsRegistrationMessageInfo fnsRegistrationMessageInfo)
+			FnsRegistrationMessageInfo fnsRegistrationMessageInfo, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
 			if (!fnsRegistrationMessageInfo.Certificates.Any()) throw new ArgumentException("fnsRegistrationMessageInfo");
-			return diadocHttpApi.SendFnsRegistrationMessageAsync(authToken, boxId, fnsRegistrationMessageInfo);
+			return diadocHttpApi.SendFnsRegistrationMessageAsync(authToken, boxId, fnsRegistrationMessageInfo, ct: ct);
 		}
 
-		public Task<Counteragent> GetCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId)
+		public Task<Counteragent> GetCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken)) throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(myOrgId)) throw new ArgumentNullException("myOrgId");
 			if (string.IsNullOrEmpty(counteragentOrgId)) throw new ArgumentNullException("counteragentOrgId");
-			return diadocHttpApi.GetCounteragentAsync(authToken, myOrgId, counteragentOrgId);
+			return diadocHttpApi.GetCounteragentAsync(authToken, myOrgId, counteragentOrgId, ct: ct);
 		}
 
-		public Task<CounteragentList> GetCounteragentsAsync(string authToken, string myOrgId, string counteragentStatus, string afterIndexKey, string query = null, int? pageSize = null)
+		public Task<CounteragentList> GetCounteragentsAsync(string authToken, string myOrgId, string counteragentStatus, string afterIndexKey, string query = null, int? pageSize = null, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken)) throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(myOrgId)) throw new ArgumentNullException("myOrgId");
-			return diadocHttpApi.GetCounteragentsAsync(authToken, myOrgId, counteragentStatus, afterIndexKey, query, pageSize);
+			return diadocHttpApi.GetCounteragentsAsync(authToken, myOrgId, counteragentStatus, afterIndexKey, query, pageSize, ct: ct);
 		}
 
-		public Task<CounteragentCertificateList> GetCounteragentCertificatesAsync(string authToken, string myOrgId, string counteragentOrgId)
+		public Task<CounteragentCertificateList> GetCounteragentCertificatesAsync(string authToken, string myOrgId, string counteragentOrgId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken)) throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(myOrgId)) throw new ArgumentNullException("myOrgId");
 			if (string.IsNullOrEmpty(counteragentOrgId)) throw new ArgumentNullException("counteragentOrgId");
-			return diadocHttpApi.GetCounteragentCertificatesAsync(authToken, myOrgId, counteragentOrgId);
+			return diadocHttpApi.GetCounteragentCertificatesAsync(authToken, myOrgId, counteragentOrgId, ct: ct);
 		}
 
-		public Task BreakWithCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId, string comment)
+		public Task BreakWithCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId, string comment, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken)) throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(myOrgId)) throw new ArgumentNullException("myOrgId");
 			if (string.IsNullOrEmpty(counteragentOrgId)) throw new ArgumentNullException("counteragentOrgId");
-			return diadocHttpApi.BreakWithCounteragentAsync(authToken, myOrgId, counteragentOrgId, comment);
+			return diadocHttpApi.BreakWithCounteragentAsync(authToken, myOrgId, counteragentOrgId, comment, ct: ct);
 		}
 
-		public Task<string> UploadFileToShelfAsync(string authToken, byte[] data)
+		public Task<string> UploadFileToShelfAsync(string authToken, byte[] data, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken)) throw new ArgumentNullException("authToken");
 			if (data == null) throw new ArgumentNullException("data");
-			return diadocHttpApi.UploadFileToShelfAsync(authToken, data);
+			return diadocHttpApi.UploadFileToShelfAsync(authToken, data, ct: ct);
 		}
 
-		public Task<byte[]> GetFileFromShelfAsync(string authToken, string nameOnShelf)
+		public Task<byte[]> GetFileFromShelfAsync(string authToken, string nameOnShelf, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken)) throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(nameOnShelf)) throw new ArgumentNullException("nameOnShelf");
-			return diadocHttpApi.GetFileFromShelfAsync(authToken, nameOnShelf);
+			return diadocHttpApi.GetFileFromShelfAsync(authToken, nameOnShelf, ct: ct);
 		}
 
-		public Task<RussianAddress> ParseRussianAddressAsync(string address)
+		public Task<RussianAddress> ParseRussianAddressAsync(string address, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseRussianAddressAsync(address);
+			return diadocHttpApi.ParseRussianAddressAsync(address, ct: ct);
 		}
 
-		public Task<InvoiceInfo> ParseInvoiceXmlAsync(byte[] invoiceXmlContent)
+		public Task<InvoiceInfo> ParseInvoiceXmlAsync(byte[] invoiceXmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseInvoiceXmlAsync(invoiceXmlContent);
+			return diadocHttpApi.ParseInvoiceXmlAsync(invoiceXmlContent, ct: ct);
 		}
 
-		public Task<Torg12SellerTitleInfo> ParseTorg12SellerTitleXmlAsync(byte[] xmlContent)
+		public Task<Torg12SellerTitleInfo> ParseTorg12SellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseTorg12SellerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseTorg12SellerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
-		public Task<Torg12BuyerTitleInfo> ParseTorg12BuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<Torg12BuyerTitleInfo> ParseTorg12BuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseTorg12BuyerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseTorg12BuyerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
-		public Task<TovTorgSellerTitleInfo> ParseTovTorg551SellerTitleXmlAsync(byte[] xmlContent)
+		public Task<TovTorgSellerTitleInfo> ParseTovTorg551SellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseTovTorg551SellerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseTovTorg551SellerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
-		public Task<TovTorgBuyerTitleInfo> ParseTovTorg551BuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<TovTorgBuyerTitleInfo> ParseTovTorg551BuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseTovTorg551BuyerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseTovTorg551BuyerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
-		public Task<AcceptanceCertificateSellerTitleInfo> ParseAcceptanceCertificateSellerTitleXmlAsync(byte[] xmlContent)
+		public Task<AcceptanceCertificateSellerTitleInfo> ParseAcceptanceCertificateSellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseAcceptanceCertificateSellerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseAcceptanceCertificateSellerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
-		public Task<AcceptanceCertificateBuyerTitleInfo> ParseAcceptanceCertificateBuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<AcceptanceCertificateBuyerTitleInfo> ParseAcceptanceCertificateBuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseAcceptanceCertificateBuyerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseAcceptanceCertificateBuyerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
-		public Task<AcceptanceCertificate552SellerTitleInfo> ParseAcceptanceCertificate552SellerTitleXmlAsync(byte[] xmlContent)
+		public Task<AcceptanceCertificate552SellerTitleInfo> ParseAcceptanceCertificate552SellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseAcceptanceCertificate552SellerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseAcceptanceCertificate552SellerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
-		public Task<AcceptanceCertificate552BuyerTitleInfo> ParseAcceptanceCertificate552BuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<AcceptanceCertificate552BuyerTitleInfo> ParseAcceptanceCertificate552BuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseAcceptanceCertificate552BuyerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseAcceptanceCertificate552BuyerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
-		public Task<UniversalTransferDocumentSellerTitleInfo> ParseUniversalTransferDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Utd)
+		public Task<UniversalTransferDocumentSellerTitleInfo> ParseUniversalTransferDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Utd, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseUniversalTransferDocumentSellerTitleXmlAsync(xmlContent, documentVersion);
+			return diadocHttpApi.ParseUniversalTransferDocumentSellerTitleXmlAsync(xmlContent, documentVersion, ct: ct);
 		}
 
-		public Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalTransferDocumentBuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalTransferDocumentBuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseUniversalTransferDocumentBuyerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseUniversalTransferDocumentBuyerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
-		public Task<UniversalCorrectionDocumentSellerTitleInfo> ParseUniversalCorrectionDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Ucd)
+		public Task<UniversalCorrectionDocumentSellerTitleInfo> ParseUniversalCorrectionDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Ucd, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseUniversalCorrectionDocumentSellerTitleXmlAsync(xmlContent, documentVersion);
+			return diadocHttpApi.ParseUniversalCorrectionDocumentSellerTitleXmlAsync(xmlContent, documentVersion, ct: ct);
 		}
 
-		public Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalCorrectionDocumentBuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalCorrectionDocumentBuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseUniversalCorrectionDocumentBuyerTitleXmlAsync(xmlContent);
+			return diadocHttpApi.ParseUniversalCorrectionDocumentBuyerTitleXmlAsync(xmlContent, ct: ct);
 		}
 
 		public Task<byte[]> ParseTitleXmlAsync(
@@ -806,7 +810,8 @@ public Task<byte[]> ParseTitleXmlAsync(
 			string documentFunction,
 			string documentVersion,
 			int titleIndex,
-			byte[] content)
+			byte[] content, 
+			CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken)) throw new ArgumentNullException(nameof(authToken));
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException(nameof(boxId));
@@ -822,25 +827,26 @@ public Task<byte[]> ParseTitleXmlAsync(
 				documentFunction,
 				documentVersion,
 				titleIndex,
-				content);
+				content, 
+				ct: ct);
 		}
 
-		public Task<OrganizationUsersList> GetOrganizationUsersAsync(string authToken, string orgId)
+		public Task<OrganizationUsersList> GetOrganizationUsersAsync(string authToken, string orgId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken)) throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(orgId)) throw new ArgumentNullException("orgId");
-			return diadocHttpApi.GetOrganizationUsersAsync(authToken, orgId);
+			return diadocHttpApi.GetOrganizationUsersAsync(authToken, orgId, ct: ct);
 		}
 
-		public Task<List<Organization>> GetOrganizationsByInnListAsync(GetOrganizationsByInnListRequest innList)
+		public Task<List<Organization>> GetOrganizationsByInnListAsync(GetOrganizationsByInnListRequest innList, CancellationToken ct = default)
 		{
 			if (innList == null)
 				throw new ArgumentNullException("innList");
-			return diadocHttpApi.GetOrganizationsByInnListAsync(innList);
+			return diadocHttpApi.GetOrganizationsByInnListAsync(innList, ct: ct);
 		}
 
 		public Task<List<OrganizationWithCounteragentStatus>> GetOrganizationsByInnListAsync(string authToken, string myOrgId,
-			GetOrganizationsByInnListRequest innList)
+			GetOrganizationsByInnListRequest innList, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
@@ -848,104 +854,104 @@ public Task<List<OrganizationWithCounteragentStatus>> GetOrganizationsByInnListA
 				throw new ArgumentNullException("myOrgId");
 			if (innList == null)
 				throw new ArgumentNullException("innList");
-			return diadocHttpApi.GetOrganizationsByInnListAsync(authToken, myOrgId, innList);
+			return diadocHttpApi.GetOrganizationsByInnListAsync(authToken, myOrgId, innList, ct: ct);
 		}
 
-		public Task<RevocationRequestInfo> ParseRevocationRequestXmlAsync(byte[] revocationRequestXmlContent)
+		public Task<RevocationRequestInfo> ParseRevocationRequestXmlAsync(byte[] revocationRequestXmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseRevocationRequestXmlAsync(revocationRequestXmlContent);
+			return diadocHttpApi.ParseRevocationRequestXmlAsync(revocationRequestXmlContent, ct: ct);
 		}
 
-		public Task<SignatureRejectionInfo> ParseSignatureRejectionXmlAsync(byte[] signatureRejectionXmlContent)
+		public Task<SignatureRejectionInfo> ParseSignatureRejectionXmlAsync(byte[] signatureRejectionXmlContent, CancellationToken ct = default)
 		{
-			return diadocHttpApi.ParseSignatureRejectionXmlAsync(signatureRejectionXmlContent);
+			return diadocHttpApi.ParseSignatureRejectionXmlAsync(signatureRejectionXmlContent, ct: ct);
 		}
 
 		public Task<DocumentProtocolResult> GenerateDocumentProtocolAsync(string authToken, string boxId, string messageId,
-			string documentId)
+			string documentId, CancellationToken ct = default)
 		{
-			return diadocHttpApi.GenerateDocumentProtocolAsync(authToken, boxId, messageId, documentId);
+			return diadocHttpApi.GenerateDocumentProtocolAsync(authToken, boxId, messageId, documentId, ct: ct);
 		}
 
 		public Task<DocumentZipGenerationResult> GenerateDocumentZipAsync(string authToken, string boxId, string messageId,
-			string documentId, bool fullDocflow)
+			string documentId, bool fullDocflow, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (messageId == null) throw new ArgumentNullException("messageId");
 			if (documentId == null) throw new ArgumentNullException("documentId");
-			return diadocHttpApi.GenerateDocumentZipAsync(authToken, boxId, messageId, documentId, fullDocflow);
+			return diadocHttpApi.GenerateDocumentZipAsync(authToken, boxId, messageId, documentId, fullDocflow, ct: ct);
 		}
 
-		public Task<DocumentList> GetDocumentsByCustomIdAsync(string authToken, string boxId, string customDocumentId)
+		public Task<DocumentList> GetDocumentsByCustomIdAsync(string authToken, string boxId, string customDocumentId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (customDocumentId == null) throw new ArgumentNullException("customDocumentId");
-			return diadocHttpApi.GetDocumentsByCustomIdAsync(authToken, boxId, customDocumentId);
+			return diadocHttpApi.GetDocumentsByCustomIdAsync(authToken, boxId, customDocumentId, ct: ct);
 		}
 
 		public Task<PrepareDocumentsToSignResponse> PrepareDocumentsToSignAsync(string authToken, PrepareDocumentsToSignRequest request,
-			bool excludeContent = false)
+			bool excludeContent = false, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
-			return diadocHttpApi.PrepareDocumentsToSignAsync(authToken, request, excludeContent);
+			return diadocHttpApi.PrepareDocumentsToSignAsync(authToken, request, excludeContent, ct: ct);
 		}
 
-		public Task<AsyncMethodResult> CloudSignAsync(string authToken, CloudSignRequest request, string certificateThumbprint)
+		public Task<AsyncMethodResult> CloudSignAsync(string authToken, CloudSignRequest request, string certificateThumbprint, CancellationToken ct = default)
 		{
 			if (request == null) throw new ArgumentNullException("request");
-			return diadocHttpApi.CloudSignAsync(authToken, request, certificateThumbprint);
+			return diadocHttpApi.CloudSignAsync(authToken, request, certificateThumbprint, ct: ct);
 		}
 
-		public Task<CloudSignResult> WaitCloudSignResultAsync(string authToken, string taskId, TimeSpan? timeout = null)
+		public Task<CloudSignResult> WaitCloudSignResultAsync(string authToken, string taskId, TimeSpan? timeout = null, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(taskId)) throw new ArgumentNullException("taskId");
-			return diadocHttpApi.WaitCloudSignResultAsync(authToken, taskId, timeout);
+			return diadocHttpApi.WaitCloudSignResultAsync(authToken, taskId, timeout, ct: ct);
 		}
 
 		public Task<AsyncMethodResult> CloudSignConfirmAsync(string authToken, string cloudSignToken, string confirmationCode,
-			ContentLocationPreference? locationPreference = null)
+			ContentLocationPreference? locationPreference = null, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(cloudSignToken)) throw new ArgumentNullException("cloudSignToken");
 			if (string.IsNullOrEmpty(confirmationCode)) throw new ArgumentNullException("confirmationCode");
-			return diadocHttpApi.CloudSignConfirmAsync(authToken, cloudSignToken, confirmationCode, locationPreference);
+			return diadocHttpApi.CloudSignConfirmAsync(authToken, cloudSignToken, confirmationCode, locationPreference, ct: ct);
 		}
 
-		public Task<CloudSignConfirmResult> WaitCloudSignConfirmResultAsync(string authToken, string taskId, TimeSpan? timeout = null)
+		public Task<CloudSignConfirmResult> WaitCloudSignConfirmResultAsync(string authToken, string taskId, TimeSpan? timeout = null, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(taskId)) throw new ArgumentNullException("taskId");
-			return diadocHttpApi.WaitCloudSignConfirmResultAsync(authToken, taskId, timeout);
+			return diadocHttpApi.WaitCloudSignConfirmResultAsync(authToken, taskId, timeout, ct: ct);
 		}
 
-		public Task<AsyncMethodResult> DssSignAsync(string authToken, string boxId, DssSignRequest request, string certificateThumbprint = null)
+		public Task<AsyncMethodResult> DssSignAsync(string authToken, string boxId, DssSignRequest request, string certificateThumbprint = null, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
 			if (request == null) throw new ArgumentNullException("request");
-			return diadocHttpApi.DssSignAsync(authToken, boxId, request, certificateThumbprint);
+			return diadocHttpApi.DssSignAsync(authToken, boxId, request, certificateThumbprint, ct: ct);
 		}
 
-		public Task<DssSignResult> DssSignResultAsync(string authToken, string boxId, string taskId)
+		public Task<DssSignResult> DssSignResultAsync(string authToken, string boxId, string taskId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(taskId)) throw new ArgumentNullException("taskId");
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.DssSignResultAsync(authToken, boxId, taskId);
+			return diadocHttpApi.DssSignResultAsync(authToken, boxId, taskId, ct: ct);
 		}
 
 		public Task<AsyncMethodResult> AcquireCounteragentAsync(string authToken, string myOrgId, AcquireCounteragentRequest request,
-			string myDepartmentId = null)
+			string myDepartmentId = null, CancellationToken ct = default)
 		{
 			if (request == null) throw new ArgumentNullException("request");
-			return diadocHttpApi.AcquireCounteragentAsync(authToken, myOrgId, request, myDepartmentId);
+			return diadocHttpApi.AcquireCounteragentAsync(authToken, myOrgId, request, myDepartmentId, ct: ct);
 		}
 
-		public Task<AcquireCounteragentResult> WaitAcquireCounteragentResultAsync(string authToken, string taskId, TimeSpan? timeout = null, TimeSpan? delay = null)
+		public Task<AcquireCounteragentResult> WaitAcquireCounteragentResultAsync(string authToken, string taskId, TimeSpan? timeout = null, TimeSpan? delay = null, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(taskId)) throw new ArgumentNullException("taskId");
-			return diadocHttpApi.WaitAcquireCounteragentResultAsync(authToken, taskId, timeout, delay);
+			return diadocHttpApi.WaitAcquireCounteragentResultAsync(authToken, taskId, timeout, delay, ct: ct);
 		}
 
-		public Task<DocumentList> GetDocumentsByMessageIdAsync(string authToken, string boxId, string messageId)
+		public Task<DocumentList> GetDocumentsByMessageIdAsync(string authToken, string boxId, string messageId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
@@ -953,10 +959,10 @@ public Task<DocumentList> GetDocumentsByMessageIdAsync(string authToken, string
 				throw new ArgumentNullException("boxId");
 			if (string.IsNullOrEmpty(messageId))
 				throw new ArgumentNullException("messageId");
-			return diadocHttpApi.GetDocumentsByMessageIdAsync(authToken, boxId, messageId);
+			return diadocHttpApi.GetDocumentsByMessageIdAsync(authToken, boxId, messageId, ct: ct);
 		}
 
-		public Task<List<KeyValueStorageEntry>> GetOrganizationStorageEntriesAsync(string authToken, string boxId, IEnumerable<string> keys)
+		public Task<List<KeyValueStorageEntry>> GetOrganizationStorageEntriesAsync(string authToken, string boxId, IEnumerable<string> keys, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
@@ -964,10 +970,10 @@ public Task<List<KeyValueStorageEntry>> GetOrganizationStorageEntriesAsync(strin
 				throw new ArgumentNullException("boxId");
 			if (keys == null)
 				throw new ArgumentNullException("keys");
-			return diadocHttpApi.GetOrganizationStorageEntriesAsync(authToken, boxId, keys);
+			return diadocHttpApi.GetOrganizationStorageEntriesAsync(authToken, boxId, keys, ct: ct);
 		}
 
-		public Task PutOrganizationStorageEntriesAsync(string authToken, string boxId, IEnumerable<KeyValueStorageEntry> entries)
+		public Task PutOrganizationStorageEntriesAsync(string authToken, string boxId, IEnumerable<KeyValueStorageEntry> entries, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
@@ -975,35 +981,35 @@ public Task PutOrganizationStorageEntriesAsync(string authToken, string boxId, I
 				throw new ArgumentNullException("boxId");
 			if (entries == null)
 				throw new ArgumentNullException("entries");
-			return diadocHttpApi.PutOrganizationStorageEntriesAsync(authToken, boxId, entries);
+			return diadocHttpApi.PutOrganizationStorageEntriesAsync(authToken, boxId, entries, ct: ct);
 		}
 
-		public Task<AsyncMethodResult> AutoSignReceiptsAsync(string authToken, string boxId, string certificateThumbprint, string batchKey)
+		public Task<AsyncMethodResult> AutoSignReceiptsAsync(string authToken, string boxId, string certificateThumbprint, string batchKey, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(boxId))
 				throw new ArgumentNullException("boxId");
-			return diadocHttpApi.AutoSignReceiptsAsync(authToken, boxId, certificateThumbprint, batchKey);
+			return diadocHttpApi.AutoSignReceiptsAsync(authToken, boxId, certificateThumbprint, batchKey, ct: ct);
 		}
 
-		public Task<AutosignReceiptsResult> WaitAutosignReceiptsResultAsync(string authToken, string taskId, TimeSpan? timeout = null)
+		public Task<AutosignReceiptsResult> WaitAutosignReceiptsResultAsync(string authToken, string taskId, TimeSpan? timeout = null, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(taskId))
 				throw new ArgumentNullException("taskId");
-			return diadocHttpApi.WaitAutosignReceiptsResultAsync(authToken, taskId, timeout);
+			return diadocHttpApi.WaitAutosignReceiptsResultAsync(authToken, taskId, timeout, ct: ct);
 		}
 
-		public Task<ExternalServiceAuthInfo> GetExternalServiceAuthInfoAsync(string key)
+		public Task<ExternalServiceAuthInfo> GetExternalServiceAuthInfoAsync(string key, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(key))
 				throw new ArgumentNullException("key");
-			return diadocHttpApi.GetExternalServiceAuthInfoAsync(key);
+			return diadocHttpApi.GetExternalServiceAuthInfoAsync(key, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection)
+		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(token))
 				throw new ArgumentNullException("token");
@@ -1011,10 +1017,10 @@ public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, s
 				throw new ArgumentNullException("boxId");
 			if (string.IsNullOrEmpty(thumbprint))
 				throw new ArgumentNullException("thumbprint");
-			return diadocHttpApi.GetExtendedSignerDetailsAsync(token, boxId, thumbprint, forBuyer, forCorrection);
+			return diadocHttpApi.GetExtendedSignerDetailsAsync(token, boxId, thumbprint, forBuyer, forCorrection, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection)
+		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(token))
 				throw new ArgumentNullException("token");
@@ -1022,10 +1028,10 @@ public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, s
 				throw new ArgumentNullException("boxId");
 			if (certificateBytes == null)
 				throw new ArgumentNullException("certificateBytes");
-			return diadocHttpApi.GetExtendedSignerDetailsAsync(token, boxId, certificateBytes, forBuyer, forCorrection);
+			return diadocHttpApi.GetExtendedSignerDetailsAsync(token, boxId, certificateBytes, forBuyer, forCorrection, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails)
+		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(token))
 				throw new ArgumentNullException("token");
@@ -1035,10 +1041,10 @@ public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token,
 				throw new ArgumentNullException("certificateBytes");
 			if (signerDetails == null)
 				throw new ArgumentNullException("signerDetails");
-			return diadocHttpApi.PostExtendedSignerDetailsAsync(token, boxId, certificateBytes, forBuyer, forCorrection, signerDetails);
+			return diadocHttpApi.PostExtendedSignerDetailsAsync(token, boxId, certificateBytes, forBuyer, forCorrection, signerDetails, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails)
+		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(token))
 				throw new ArgumentNullException("token");
@@ -1048,29 +1054,29 @@ public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token,
 				throw new ArgumentNullException("thumbprint");
 			if (signerDetails == null)
 				throw new ArgumentNullException("signerDetails");
-			return diadocHttpApi.PostExtendedSignerDetailsAsync(token, boxId, thumbprint, forBuyer, forCorrection, signerDetails);
+			return diadocHttpApi.PostExtendedSignerDetailsAsync(token, boxId, thumbprint, forBuyer, forCorrection, signerDetails, ct: ct);
 		}
 
-		public Task<ResolutionRouteList> GetResolutionRoutesForOrganizationAsync(string authToken, string orgId)
+		public Task<ResolutionRouteList> GetResolutionRoutesForOrganizationAsync(string authToken, string orgId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(orgId))
 				throw new ArgumentNullException("orgId");
-			return diadocHttpApi.GetResolutionRoutesForOrganizationAsync(authToken, orgId);
+			return diadocHttpApi.GetResolutionRoutesForOrganizationAsync(authToken, orgId, ct: ct);
 		}
 
-		public Task<GetDocumentTypesResponse> GetDocumentTypesAsync(string authToken, string boxId)
+		public Task<GetDocumentTypesResponse> GetDocumentTypesAsync(string authToken, string boxId, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(boxId))
 				throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetDocumentTypesAsync(authToken, boxId);
+			return diadocHttpApi.GetDocumentTypesAsync(authToken, boxId, ct: ct);
 		}
 
 		[Obsolete("Use DetectDocumentTitlesAsync")]
-		public Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, string nameOnShelf)
+		public Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, string nameOnShelf, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
@@ -1078,20 +1084,20 @@ public Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authTok
 				throw new ArgumentNullException("boxId");
 			if (string.IsNullOrEmpty(nameOnShelf))
 				throw new ArgumentNullException("nameOnShelf");
-			return diadocHttpApi.DetectDocumentTypesAsync(authToken, boxId, nameOnShelf);
+			return diadocHttpApi.DetectDocumentTypesAsync(authToken, boxId, nameOnShelf, ct: ct);
 		}
 
 		[Obsolete("Use DetectDocumentTitlesAsync")]
-		public Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, byte[] content)
+		public Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, byte[] content, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(boxId))
 				throw new ArgumentNullException("boxId");
-			return diadocHttpApi.DetectDocumentTypesAsync(authToken, boxId, content);
+			return diadocHttpApi.DetectDocumentTypesAsync(authToken, boxId, content, ct: ct);
 		}
 		
-		public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, string nameOnShelf)
+		public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, string nameOnShelf, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
@@ -1099,19 +1105,19 @@ public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, str
 				throw new ArgumentNullException("boxId");
 			if (string.IsNullOrEmpty(nameOnShelf))
 				throw new ArgumentNullException("nameOnShelf");
-			return diadocHttpApi.DetectDocumentTitlesAsync(authToken, boxId, nameOnShelf);
+			return diadocHttpApi.DetectDocumentTitlesAsync(authToken, boxId, nameOnShelf, ct: ct);
 		}
 
-		public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, byte[] content)
+		public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, byte[] content, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
 			if (string.IsNullOrEmpty(boxId))
 				throw new ArgumentNullException("boxId");
-			return diadocHttpApi.DetectDocumentTitlesAsync(authToken, boxId, content);
+			return diadocHttpApi.DetectDocumentTitlesAsync(authToken, boxId, content, ct: ct);
 		}
 
-		public Task<FileContent> GetContentAsync(string authToken, string typeNamedId, string function, string version, int titleIndex, XsdContentType contentType = default(XsdContentType))
+		public Task<FileContent> GetContentAsync(string authToken, string typeNamedId, string function, string version, int titleIndex, XsdContentType contentType = default(XsdContentType), CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(authToken))
 				throw new ArgumentNullException("authToken");
@@ -1123,18 +1129,18 @@ public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, str
 				throw new ArgumentNullException("version");
 			if (titleIndex < 0)
 				throw new ArgumentOutOfRangeException("titleIndex", titleIndex, "Title index should be non-negative");
-			return diadocHttpApi.GetContentAsync(authToken, typeNamedId, function, version, titleIndex, contentType);
+			return diadocHttpApi.GetContentAsync(authToken, typeNamedId, function, version, titleIndex, contentType, ct: ct);
 		}
 
-		public Task<Employee> GetEmployeeAsync(string authToken, string boxId, string userId)
+		public Task<Employee> GetEmployeeAsync(string authToken, string boxId, string userId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (userId == null) throw new ArgumentNullException("userId");
-			return diadocHttpApi.GetEmployeeAsync(authToken, boxId, userId);
+			return diadocHttpApi.GetEmployeeAsync(authToken, boxId, userId, ct: ct);
 		}
 
-		public Task<EmployeeList> GetEmployeesAsync(string authToken, string boxId, int? page, int? count)
+		public Task<EmployeeList> GetEmployeesAsync(string authToken, string boxId, int? page, int? count, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
@@ -1142,124 +1148,124 @@ public Task<EmployeeList> GetEmployeesAsync(string authToken, string boxId, int?
 				throw new ArgumentOutOfRangeException("page", page, "page must be 1 or greater");
 			if (count < 1)
 				throw new ArgumentOutOfRangeException("count", count, "count must be 1 or greater");
-			return diadocHttpApi.GetEmployeesAsync(authToken, boxId, page, count);
+			return diadocHttpApi.GetEmployeesAsync(authToken, boxId, page, count, ct: ct);
 		}
 
-		public Task<Employee> CreateEmployeeAsync(string authToken, string boxId, EmployeeToCreate employeeToCreate)
+		public Task<Employee> CreateEmployeeAsync(string authToken, string boxId, EmployeeToCreate employeeToCreate, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (employeeToCreate == null) throw new ArgumentNullException("employeeToCreate");
-			return diadocHttpApi.CreateEmployeeAsync(authToken, boxId, employeeToCreate);
+			return diadocHttpApi.CreateEmployeeAsync(authToken, boxId, employeeToCreate, ct: ct);
 		}
 
-		public Task<Employee> UpdateEmployeeAsync(string authToken, string boxId, string userId, EmployeeToUpdate employeeToUpdate)
+		public Task<Employee> UpdateEmployeeAsync(string authToken, string boxId, string userId, EmployeeToUpdate employeeToUpdate, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (userId == null) throw new ArgumentNullException("userId");
 			if (employeeToUpdate == null) throw new ArgumentNullException("employeeToUpdate");
-			return diadocHttpApi.UpdateEmployeeAsync(authToken, boxId, userId, employeeToUpdate);
+			return diadocHttpApi.UpdateEmployeeAsync(authToken, boxId, userId, employeeToUpdate, ct: ct);
 		}
 
-		public Task DeleteEmployeeAsync(string authToken, string boxId, string userId)
+		public Task DeleteEmployeeAsync(string authToken, string boxId, string userId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (userId == null) throw new ArgumentNullException("userId");
-			return diadocHttpApi.DeleteEmployeeAsync(authToken, boxId, userId);
+			return diadocHttpApi.DeleteEmployeeAsync(authToken, boxId, userId, ct: ct);
 		}
 
-		public Task<Employee> GetMyEmployeeAsync(string authToken, string boxId)
+		public Task<Employee> GetMyEmployeeAsync(string authToken, string boxId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetMyEmployeeAsync(authToken, boxId);
+			return diadocHttpApi.GetMyEmployeeAsync(authToken, boxId, ct: ct);
 		}
 
-		public Task<EmployeeSubscriptions> GetSubscriptionsAsync(string authToken, string boxId, string userId)
+		public Task<EmployeeSubscriptions> GetSubscriptionsAsync(string authToken, string boxId, string userId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (userId == null) throw new ArgumentNullException("userId");
-			return diadocHttpApi.GetSubscriptionsAsync(authToken, boxId, userId);
+			return diadocHttpApi.GetSubscriptionsAsync(authToken, boxId, userId, ct: ct);
 		}
 
-		public Task<EmployeeSubscriptions> UpdateSubscriptionsAsync(string authToken, string boxId, string userId, SubscriptionsToUpdate subscriptionsToUpdate)
+		public Task<EmployeeSubscriptions> UpdateSubscriptionsAsync(string authToken, string boxId, string userId, SubscriptionsToUpdate subscriptionsToUpdate, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (userId == null) throw new ArgumentNullException("userId");
-			return diadocHttpApi.UpdateSubscriptionsAsync(authToken, boxId, userId, subscriptionsToUpdate);
+			return diadocHttpApi.UpdateSubscriptionsAsync(authToken, boxId, userId, subscriptionsToUpdate, ct: ct);
 		}
 
-		public Task<Departments.Department> GetDepartmentByFullIdAsync(string authToken, string boxId, string departmentId)
+		public Task<Departments.Department> GetDepartmentByFullIdAsync(string authToken, string boxId, string departmentId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (departmentId == null) throw new ArgumentNullException("departmentId");
-			return diadocHttpApi.GetDepartmentByFullIdAsync(authToken, boxId, departmentId);
+			return diadocHttpApi.GetDepartmentByFullIdAsync(authToken, boxId, departmentId, ct: ct);
 		}
 
-		public Task<Departments.DepartmentList> GetDepartmentsAsync(string authToken, string boxId, int? page = null, int? count = null)
+		public Task<Departments.DepartmentList> GetDepartmentsAsync(string authToken, string boxId, int? page = null, int? count = null, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetDepartmentsAsync(authToken, boxId, page, count);
+			return diadocHttpApi.GetDepartmentsAsync(authToken, boxId, page, count, ct: ct);
 		}
 
-		public Task<Departments.Department> CreateDepartmentAsync(string authToken, string boxId, Departments.DepartmentToCreate departmentToCreate)
+		public Task<Departments.Department> CreateDepartmentAsync(string authToken, string boxId, Departments.DepartmentToCreate departmentToCreate, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.CreateDepartmentAsync(authToken, boxId, departmentToCreate);
+			return diadocHttpApi.CreateDepartmentAsync(authToken, boxId, departmentToCreate, ct: ct);
 		}
 
-		public Task<Departments.Department> UpdateDepartmentAsync(string authToken, string boxId, string departmentId, Departments.DepartmentToUpdate departmentToUpdate)
+		public Task<Departments.Department> UpdateDepartmentAsync(string authToken, string boxId, string departmentId, Departments.DepartmentToUpdate departmentToUpdate, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (departmentId == null) throw new ArgumentNullException("departmentId");
-			return diadocHttpApi.UpdateDepartmentAsync(authToken, boxId, departmentId, departmentToUpdate);
+			return diadocHttpApi.UpdateDepartmentAsync(authToken, boxId, departmentId, departmentToUpdate, ct: ct);
 		}
 
-		public Task DeleteDepartmentAsync(string authToken, string boxId, string departmentId)
+		public Task DeleteDepartmentAsync(string authToken, string boxId, string departmentId, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (departmentId == null) throw new ArgumentNullException("departmentId");
-			return diadocHttpApi.DeleteDepartmentAsync(authToken, boxId, departmentId);
+			return diadocHttpApi.DeleteDepartmentAsync(authToken, boxId, departmentId, ct: ct);
 		}
 
-		public Task<RegistrationResponse> RegisterAsync(string authToken, RegistrationRequest registrationRequest)
+		public Task<RegistrationResponse> RegisterAsync(string authToken, RegistrationRequest registrationRequest, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (registrationRequest == null) throw new ArgumentNullException("registrationRequest");
-			return diadocHttpApi.RegisterAsync(authToken, registrationRequest);
+			return diadocHttpApi.RegisterAsync(authToken, registrationRequest, ct: ct);
 		}
 
-		public Task RegisterConfirmAsync(string authToken, RegistrationConfirmRequest registrationConfirmRequest)
+		public Task RegisterConfirmAsync(string authToken, RegistrationConfirmRequest registrationConfirmRequest, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (registrationConfirmRequest == null) throw new ArgumentNullException("registrationConfirmRequest");
-			return diadocHttpApi.RegisterConfirmAsync(authToken, registrationConfirmRequest);
+			return diadocHttpApi.RegisterConfirmAsync(authToken, registrationConfirmRequest, ct: ct);
 		}
 
 		public Task<CustomPrintFormDetectionResult> DetectCustomPrintFormsAsync(string authToken,
 			string boxId,
-			CustomPrintFormDetectionRequest request)
+			CustomPrintFormDetectionRequest request, CancellationToken ct = default)
 		{
 			if (authToken == null) throw new ArgumentNullException("authToken");
 			if (boxId == null) throw new ArgumentNullException("boxId");
 			if (request == null) throw new ArgumentNullException("request");
-			return diadocHttpApi.DetectCustomPrintFormsAsync(authToken, boxId, request);
+			return diadocHttpApi.DetectCustomPrintFormsAsync(authToken, boxId, request, ct: ct);
 		}
 
-		public Task<BoxEvent> GetLastEventAsync(string authToken, string boxId)
+		public Task<BoxEvent> GetLastEventAsync(string authToken, string boxId, CancellationToken ct = default)
 		{
 			if(authToken == null) throw new ArgumentNullException("authToken");
 			if(boxId == null) throw new ArgumentNullException("boxId");
-			return diadocHttpApi.GetLastEventAsync(authToken, boxId);
+			return diadocHttpApi.GetLastEventAsync(authToken, boxId, ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.Async.cs b/src/DiadocHttpApi.Async.cs
index 90fc23e9..349f3b1b 100644
--- a/src/DiadocHttpApi.Async.cs
+++ b/src/DiadocHttpApi.Async.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Proto.Events;
 using JetBrains.Annotations;
@@ -9,17 +10,17 @@ namespace Diadoc.Api
 	public partial class DiadocHttpApi
 	{
 		[ItemNotNull]
-		protected Task<byte[]> PerformHttpRequestAsync([CanBeNull] string token, [NotNull] string method, [NotNull] string queryString, [CanBeNull] byte[] requestBody = null)
+		protected Task<byte[]> PerformHttpRequestAsync([CanBeNull] string token, [NotNull] string method, [NotNull] string queryString, [CanBeNull] byte[] requestBody = null, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync(token, method, queryString, requestBody, responseContent => responseContent);
+			return PerformHttpRequestAsync(token, method, queryString, requestBody, responseContent => responseContent, ct: ct);
 		}
 
 		[ItemNotNull]
-		protected Task<TResponse> PerformHttpRequestAsync<TRequest, TResponse>([CanBeNull] string token, [NotNull] string queryString, [NotNull] TRequest request)
+		protected Task<TResponse> PerformHttpRequestAsync<TRequest, TResponse>([CanBeNull] string token, [NotNull] string queryString, [NotNull] TRequest request, CancellationToken ct = default)
 			where TRequest: class
 			where TResponse: class
 		{
-			return PerformHttpRequestAsync(token, "POST", queryString, Serialize(request), Deserialize<TResponse>);
+			return PerformHttpRequestAsync(token, "POST", queryString, Serialize(request), Deserialize<TResponse>, ct: ct);
 		}
 
 		[ItemNotNull]
@@ -27,11 +28,12 @@ protected Task<TResponse> PerformHttpRequestAsync<TResponse>(
 			[CanBeNull] string token, 
 			[NotNull] string method, 
 			[NotNull] string queryString, 
-			[CanBeNull] byte[] requestBody = null,
+			[CanBeNull] byte[] requestBody = null, 
+			CancellationToken ct = default,
 			params HttpStatusCode[] allowStatusCodes)
 			where TResponse: class
 		{
-			return PerformHttpRequestAsync(token, method, queryString, requestBody, Deserialize<TResponse>, allowStatusCodes);
+			return PerformHttpRequestAsync(token, method, queryString, requestBody, Deserialize<TResponse>, ct: ct, allowStatusCodes);
 		}
 
 		[ItemNotNull]
@@ -40,20 +42,21 @@ protected async Task<TResponse> PerformHttpRequestAsync<TResponse>(
 			[NotNull] string method, 
 			[NotNull] string queryString, 
 			[CanBeNull] byte[] requestBody, 
-			[NotNull] Func<byte[], TResponse> convertResponse, 
+			[NotNull] Func<byte[], TResponse> convertResponse,
+			CancellationToken ct = default,
 			params HttpStatusCode[] allowStatusCodes)
 		{
 			var request = BuildHttpRequest(token, method, queryString, requestBody);
-			var response = await HttpClient.PerformHttpRequestAsync(request, allowStatusCodes).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct, allowStatusCodes).ConfigureAwait(false);
 			return DeserializeResponse(request, response, convertResponse);
 		}
 
 		[ItemNotNull]
-		protected async Task<GeneratedFile> PerformGenerateXmlHttpRequestAsync<TRequest>([CanBeNull] string token, [NotNull] string queryString, [NotNull] TRequest requestObject)
+		protected async Task<GeneratedFile> PerformGenerateXmlHttpRequestAsync<TRequest>([CanBeNull] string token, [NotNull] string queryString, [NotNull] TRequest requestObject, CancellationToken ct = default)
 			where TRequest: class
 		{
 			var request = BuildHttpRequest(token, "POST", queryString, Serialize(requestObject));
-			var response = await HttpClient.PerformHttpRequestAsync(request).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct).ConfigureAwait(false);
 			return new GeneratedFile(response.ContentDispositionFileName, response.Content);
 		}
 	}
diff --git a/src/DiadocHttpApi.AuthAsync.cs b/src/DiadocHttpApi.AuthAsync.cs
index 106f5280..62e40b73 100644
--- a/src/DiadocHttpApi.AuthAsync.cs
+++ b/src/DiadocHttpApi.AuthAsync.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 
@@ -7,7 +8,7 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public async Task<string> AuthenticateAsync(string login, string password, string key = null, string id = null)
+		public async Task<string> AuthenticateAsync(string login, string password, string key = null, string id = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V2/Authenticate");
 			qsb.AddParameter("login", login);
@@ -18,40 +19,41 @@ public async Task<string> AuthenticateAsync(string login, string password, strin
 				qsb.AddParameter("id", id);
 			}
 
-			var httpResponse = await PerformHttpRequestAsync(null, "POST", qsb.BuildPathAndQuery()).ConfigureAwait(false);
+			var httpResponse = await PerformHttpRequestAsync(null, "POST", qsb.BuildPathAndQuery(), ct: ct).ConfigureAwait(false);
 			return Encoding.UTF8.GetString(httpResponse);
 		}
 
-		public async Task<string> AuthenticateByKeyAsync(string key, string id)
+		public async Task<string> AuthenticateByKeyAsync(string key, string id, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V2/Authenticate");
 			qsb.AddParameter("key", key);
 			qsb.AddParameter("id", id);
-			var httpResponse = await PerformHttpRequestAsync(null, "POST", qsb.BuildPathAndQuery()).ConfigureAwait(false);
+			var httpResponse = await PerformHttpRequestAsync(null, "POST", qsb.BuildPathAndQuery(), ct: ct).ConfigureAwait(false);
 			return Encoding.UTF8.GetString(httpResponse);
 		}
 
-		public async Task<string> AuthenticateBySidAsync(string sid)
+		public async Task<string> AuthenticateBySidAsync(string sid, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V2/Authenticate");
 			qsb.AddParameter("sid", sid);
-			var httpResponse = await PerformHttpRequestAsync(null, "POST", qsb.BuildPathAndQuery()).ConfigureAwait(false);
+			var httpResponse = await PerformHttpRequestAsync(null, "POST", qsb.BuildPathAndQuery(), ct: ct).ConfigureAwait(false);
 			return Encoding.UTF8.GetString(httpResponse);
 		}
 
-		public async Task<string> AuthenticateAsync(byte[] certificateBytes, bool useLocalSystemStorage = false)
+		public async Task<string> AuthenticateAsync(byte[] certificateBytes, bool useLocalSystemStorage = false, CancellationToken ct = default)
 		{
 			var token = await AuthenticateByCertificateAsync(
 					certificateBytes,
 					useLocalSystemStorage,
 					key: null,
-					id: null)
+					id: null, 
+					ct: ct)
 				.ConfigureAwait(false);
 
-			return await ConfirmAuthenticationByCertificateAsync(certificateBytes, token, saveBinding: false).ConfigureAwait(false);
+			return await ConfirmAuthenticationByCertificateAsync(certificateBytes, token, saveBinding: false, ct: ct).ConfigureAwait(false);
 		}
 
-		public async Task<string> AuthenticateAsync(string thumbprint, bool useLocalSystemStorage = false)
+		public async Task<string> AuthenticateAsync(string thumbprint, bool useLocalSystemStorage = false, CancellationToken ct = default)
 		{
 			var userCert = crypt.GetCertificateWithPrivateKey(thumbprint, useLocalSystemStorage);
 
@@ -59,46 +61,47 @@ public async Task<string> AuthenticateAsync(string thumbprint, bool useLocalSyst
 					userCert.RawData,
 					useLocalSystemStorage,
 					key: null,
-					id: null)
+					id: null, 
+					ct: ct)
 				.ConfigureAwait(false);
 
-			return await ConfirmAuthenticationByCertificateThumbprintAsync(userCert.Thumbprint, token, saveBinding: false).ConfigureAwait(false);
+			return await ConfirmAuthenticationByCertificateThumbprintAsync(userCert.Thumbprint, token, saveBinding: false, ct: ct).ConfigureAwait(false);
 		}
 
-		public async Task<string> AuthenticateWithKeyAsync(byte[] certificateBytes, bool useLocalSystemStorage = false, string key = null, string id = null, bool autoConfirm = true)
+		public async Task<string> AuthenticateWithKeyAsync(byte[] certificateBytes, bool useLocalSystemStorage = false, string key = null, string id = null, bool autoConfirm = true, CancellationToken ct = default)
 		{
 			var authenticationWithKey = !string.IsNullOrEmpty(key);
 
-			var token = await AuthenticateByCertificateAsync(certificateBytes, useLocalSystemStorage, key, id).ConfigureAwait(false);
+			var token = await AuthenticateByCertificateAsync(certificateBytes, useLocalSystemStorage, key, id, ct: ct).ConfigureAwait(false);
 
 			return autoConfirm
-				? await ConfirmAuthenticationByCertificateAsync(certificateBytes, token, saveBinding: authenticationWithKey).ConfigureAwait(false)
+				? await ConfirmAuthenticationByCertificateAsync(certificateBytes, token, saveBinding: authenticationWithKey, ct: ct).ConfigureAwait(false)
 				: token;
 		}
 
-		public async Task<string> AuthenticateWithKeyAsync(string thumbprint, bool useLocalSystemStorage = false, string key = null, string id = null, bool autoConfirm = true)
+		public async Task<string> AuthenticateWithKeyAsync(string thumbprint, bool useLocalSystemStorage = false, string key = null, string id = null, bool autoConfirm = true, CancellationToken ct = default)
 		{
 			var authenticationWithKey = !string.IsNullOrEmpty(key);
 			var userCert = crypt.GetCertificateWithPrivateKey(thumbprint, useLocalSystemStorage);
 
-			var token = await AuthenticateByCertificateAsync(userCert.RawData, useLocalSystemStorage, key, id).ConfigureAwait(false);
+			var token = await AuthenticateByCertificateAsync(userCert.RawData, useLocalSystemStorage, key, id, ct: ct).ConfigureAwait(false);
 
 			return autoConfirm
-				? await ConfirmAuthenticationByCertificateThumbprintAsync(userCert.Thumbprint, token, saveBinding: authenticationWithKey).ConfigureAwait(false)
+				? await ConfirmAuthenticationByCertificateThumbprintAsync(userCert.Thumbprint, token, saveBinding: authenticationWithKey, ct: ct).ConfigureAwait(false)
 				: token;
 		}
 
-		public Task<string> AuthenticateWithKeyConfirmAsync(byte[] certificateBytes, string token, bool saveBinding = false)
+		public Task<string> AuthenticateWithKeyConfirmAsync(byte[] certificateBytes, string token, bool saveBinding = false, CancellationToken ct = default)
 		{
-			return ConfirmAuthenticationByCertificateAsync(certificateBytes, token, saveBinding);
+			return ConfirmAuthenticationByCertificateAsync(certificateBytes, token, saveBinding, ct: ct);
 		}
 
-		public Task<string> AuthenticateWithKeyConfirmAsync(string thumbprint, string token, bool saveBinding = false)
+		public Task<string> AuthenticateWithKeyConfirmAsync(string thumbprint, string token, bool saveBinding = false, CancellationToken ct = default)
 		{
-			return ConfirmAuthenticationByCertificateThumbprintAsync(thumbprint, token, saveBinding);
+			return ConfirmAuthenticationByCertificateThumbprintAsync(thumbprint, token, saveBinding, ct: ct);
 		}
 
-		private Task<string> AuthenticateByCertificateAsync(byte[] certificateBytes, bool useLocalSystemStorage, string key, string id)
+		private Task<string> AuthenticateByCertificateAsync(byte[] certificateBytes, bool useLocalSystemStorage, string key, string id, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V2/Authenticate");
 			var authenticationWithKey = !string.IsNullOrEmpty(key);
@@ -113,10 +116,11 @@ private Task<string> AuthenticateByCertificateAsync(byte[] certificateBytes, boo
 				"POST",
 				qsb.BuildPathAndQuery(),
 				certificateBytes,
-				responseContent => Convert.ToBase64String(crypt.Decrypt(responseContent, useLocalSystemStorage)));
+				responseContent => Convert.ToBase64String(crypt.Decrypt(responseContent, useLocalSystemStorage)),
+				ct: ct);
 		}
 
-		private Task<string> ConfirmAuthenticationByCertificateAsync(byte[] certificateBytes, string token, bool saveBinding)
+		private Task<string> ConfirmAuthenticationByCertificateAsync(byte[] certificateBytes, string token, bool saveBinding, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V2/AuthenticateConfirm");
 			qsb.AddParameter("token", token);
@@ -126,10 +130,11 @@ private Task<string> ConfirmAuthenticationByCertificateAsync(byte[] certificateB
 				"POST",
 				qsb.BuildPathAndQuery(),
 				certificateBytes,
-				responseContent => Encoding.UTF8.GetString(responseContent));
+				responseContent => Encoding.UTF8.GetString(responseContent),
+				ct: ct);
 		}
 
-		private Task<string> ConfirmAuthenticationByCertificateThumbprintAsync(string thumbprint, string token, bool saveBinding)
+		private Task<string> ConfirmAuthenticationByCertificateThumbprintAsync(string thumbprint, string token, bool saveBinding, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V2/AuthenticateConfirm");
 			qsb.AddParameter("thumbprint", thumbprint);
@@ -140,7 +145,8 @@ private Task<string> ConfirmAuthenticationByCertificateThumbprintAsync(string th
 				"POST",
 				qsb.BuildPathAndQuery(),
 				null,
-				responseContent => Encoding.UTF8.GetString(responseContent));
+				responseContent => Encoding.UTF8.GetString(responseContent),
+				ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.CloudCryptAsync.cs b/src/DiadocHttpApi.CloudCryptAsync.cs
index e0a5a24a..b1d7ef3c 100644
--- a/src/DiadocHttpApi.CloudCryptAsync.cs
+++ b/src/DiadocHttpApi.CloudCryptAsync.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto;
@@ -8,35 +9,35 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<AsyncMethodResult> CloudSignAsync(string authToken, CloudSignRequest request, string certificateThumbprint = null)
+		public Task<AsyncMethodResult> CloudSignAsync(string authToken, CloudSignRequest request, string certificateThumbprint = null, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/CloudSign");
 			if (!string.IsNullOrEmpty(certificateThumbprint))
 				queryString.AddParameter("certificateThumbprint", certificateThumbprint);
-			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery(), Serialize(request));
+			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery(), Serialize(request), ct: ct);
 		}
 
-		public Task<CloudSignResult> WaitCloudSignResultAsync(string authToken, string taskId, TimeSpan? timeout = null)
+		public Task<CloudSignResult> WaitCloudSignResultAsync(string authToken, string taskId, TimeSpan? timeout = null, CancellationToken ct = default)
 		{
-			return WaitTaskResultAsync<CloudSignResult>(authToken, "/CloudSignResult", taskId, timeout);
+			return WaitTaskResultAsync<CloudSignResult>(authToken, "/CloudSignResult", taskId, timeout, ct: ct);
 		}
 
-		public Task<AsyncMethodResult> CloudSignConfirmAsync(string authToken, string cloudSignToken, string confirmationCode, ContentLocationPreference? locationPreference = null)
+		public Task<AsyncMethodResult> CloudSignConfirmAsync(string authToken, string cloudSignToken, string confirmationCode, ContentLocationPreference? locationPreference = null, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/CloudSignConfirm");
 			queryString.AddParameter("token", cloudSignToken);
 			queryString.AddParameter("confirmationCode", confirmationCode);
 			if (locationPreference.HasValue)
 				queryString.AddParameter("return", locationPreference.Value.ToString());
-			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<CloudSignConfirmResult> WaitCloudSignConfirmResultAsync(string authToken, string taskId, TimeSpan? timeout = null)
+		public Task<CloudSignConfirmResult> WaitCloudSignConfirmResultAsync(string authToken, string taskId, TimeSpan? timeout = null, CancellationToken ct = default)
 		{
-			return WaitTaskResultAsync<CloudSignConfirmResult>(authToken, "/CloudSignConfirmResult", taskId, timeout);
+			return WaitTaskResultAsync<CloudSignConfirmResult>(authToken, "/CloudSignConfirmResult", taskId, timeout, ct: ct);
 		}
 
-		public Task<AsyncMethodResult> AutoSignReceiptsAsync(string authToken, string boxId, string certificateThumbprint, string batchKey)
+		public Task<AsyncMethodResult> AutoSignReceiptsAsync(string authToken, string boxId, string certificateThumbprint, string batchKey, CancellationToken ct = default)
 		{
 			if (boxId == null) throw new ArgumentNullException(nameof(boxId));
 			var queryString = new PathAndQueryBuilder("/AutoSignReceipts");
@@ -45,15 +46,15 @@ public Task<AsyncMethodResult> AutoSignReceiptsAsync(string authToken, string bo
 				queryString.AddParameter("certificateThumbprint", certificateThumbprint);
 			if (!string.IsNullOrEmpty(batchKey))
 				queryString.AddParameter("batchKey", batchKey);
-			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<AutosignReceiptsResult> WaitAutosignReceiptsResultAsync(string authToken, string taskId, TimeSpan? timeout = null)
+		public Task<AutosignReceiptsResult> WaitAutosignReceiptsResultAsync(string authToken, string taskId, TimeSpan? timeout = null, CancellationToken ct = default)
 		{
-			return WaitTaskResultAsync<AutosignReceiptsResult>(authToken, "/AutosignReceiptsResult", taskId, timeout);
+			return WaitTaskResultAsync<AutosignReceiptsResult>(authToken, "/AutosignReceiptsResult", taskId, timeout, ct: ct);
 		}
 
-		public Task<AsyncMethodResult> DssSignAsync(string authToken, string boxId, DssSignRequest request, string certificateThumbprint = null)
+		public Task<AsyncMethodResult> DssSignAsync(string authToken, string boxId, DssSignRequest request, string certificateThumbprint = null, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/DssSign");
 			queryString.AddParameter("boxId", boxId);
@@ -62,15 +63,15 @@ public Task<AsyncMethodResult> DssSignAsync(string authToken, string boxId, DssS
 				queryString.AddParameter("certificateThumbprint", certificateThumbprint);
 			}
 
-			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery(), Serialize(request));
+			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery(), Serialize(request), ct: ct);
 		}
 
-		public Task<DssSignResult> DssSignResultAsync(string authToken, string boxId, string taskId)
+		public Task<DssSignResult> DssSignResultAsync(string authToken, string boxId, string taskId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/DssSignResult");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("taskId", taskId);
-			return PerformHttpRequestAsync<DssSignResult>(authToken, "GET", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<DssSignResult>(authToken, "GET", queryString.BuildPathAndQuery(), ct: ct);
 		}
 	}
 }
diff --git a/src/DiadocHttpApi.CounteragentsAsync.cs b/src/DiadocHttpApi.CounteragentsAsync.cs
index 6bc65f73..1a59a5ba 100644
--- a/src/DiadocHttpApi.CounteragentsAsync.cs
+++ b/src/DiadocHttpApi.CounteragentsAsync.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto;
@@ -7,15 +8,15 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<Counteragent> GetCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId)
+		public Task<Counteragent> GetCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("V2/GetCounteragent");
 			qsb.AddParameter("myOrgId", myOrgId);
 			qsb.AddParameter("counteragentOrgId", counteragentOrgId);
-			return PerformHttpRequestAsync<Counteragent>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<Counteragent>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<CounteragentList> GetCounteragentsAsync(string authToken, string myOrgId, string counteragentStatus, string afterIndexKey, string query = null, int? pageSize = null)
+		public Task<CounteragentList> GetCounteragentsAsync(string authToken, string myOrgId, string counteragentStatus, string afterIndexKey, string query = null, int? pageSize = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("V2/GetCounteragents");
 			qsb.AddParameter("myOrgId", myOrgId);
@@ -23,40 +24,41 @@ public Task<CounteragentList> GetCounteragentsAsync(string authToken, string myO
 			if (!string.IsNullOrEmpty(afterIndexKey)) qsb.AddParameter("afterIndexKey", afterIndexKey);
 			if (!string.IsNullOrEmpty(query)) qsb.AddParameter("query", query);
 			if (pageSize != null) qsb.AddParameter("pageSize", pageSize.ToString());
-			return PerformHttpRequestAsync<CounteragentList>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<CounteragentList>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
 
 		public Task<CounteragentCertificateList> GetCounteragentCertificatesAsync(
 			string authToken,
 			string myOrgId,
-			string counteragentOrgId)
+			string counteragentOrgId, 
+			CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetCounteragentCertificates");
 			qsb.AddParameter("myOrgId", myOrgId);
 			qsb.AddParameter("counteragentOrgId", counteragentOrgId);
-			return PerformHttpRequestAsync<CounteragentCertificateList>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<CounteragentCertificateList>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task BreakWithCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId, string comment)
+		public Task BreakWithCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId, string comment, CancellationToken ct = default)
 		{
 			var qsb = CounteragentOperationPathAndQuery("/BreakWithCounteragent", myOrgId, counteragentOrgId, comment);
-			return PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<AsyncMethodResult> AcquireCounteragentAsync(string authToken, string myOrgId, AcquireCounteragentRequest request, string myDepartmentId = null)
+		public Task<AsyncMethodResult> AcquireCounteragentAsync(string authToken, string myOrgId, AcquireCounteragentRequest request, string myDepartmentId = null, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/V2/AcquireCounteragent");
 			queryString.AddParameter("myOrgId", myOrgId);
 			if (!string.IsNullOrEmpty(myDepartmentId))
 				queryString.AddParameter("myDepartmentId", myDepartmentId);
 
-			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery(), Serialize(request));
+			return PerformHttpRequestAsync<AsyncMethodResult>(authToken, "POST", queryString.BuildPathAndQuery(), Serialize(request), ct: ct);
 		}
 
-		public Task<AcquireCounteragentResult> WaitAcquireCounteragentResultAsync(string authToken, string taskId, TimeSpan? timeout = null, TimeSpan? delay = null)
+		public Task<AcquireCounteragentResult> WaitAcquireCounteragentResultAsync(string authToken, string taskId, TimeSpan? timeout = null, TimeSpan? delay = null, CancellationToken ct = default)
 		{
-			return WaitTaskResultAsync<AcquireCounteragentResult>(authToken, "/AcquireCounteragentResult", taskId, timeout, delay);
+			return WaitTaskResultAsync<AcquireCounteragentResult>(authToken, "/AcquireCounteragentResult", taskId, timeout, delay, ct: ct);
 		}
 	}
 }
diff --git a/src/DiadocHttpApi.Departments.Async.cs b/src/DiadocHttpApi.Departments.Async.cs
index 9364aec2..240dee50 100644
--- a/src/DiadocHttpApi.Departments.Async.cs
+++ b/src/DiadocHttpApi.Departments.Async.cs
@@ -1,3 +1,4 @@
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Departments;
@@ -6,44 +7,44 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<Department> GetDepartmentByFullIdAsync(string authToken, string boxId, string departmentId)
+		public Task<Department> GetDepartmentByFullIdAsync(string authToken, string boxId, string departmentId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/admin/GetDepartment");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("departmentId", departmentId);
-			return PerformHttpRequestAsync<Department>(authToken, "GET", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<Department>(authToken, "GET", queryString.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<DepartmentList> GetDepartmentsAsync(string authToken, string boxId, int? page = null, int? count = null)
+		public Task<DepartmentList> GetDepartmentsAsync(string authToken, string boxId, int? page = null, int? count = null, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/admin/GetDepartments");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("page", page?.ToString());
 			queryString.AddParameter("count", count?.ToString());
-			return PerformHttpRequestAsync<DepartmentList>(authToken, "GET", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<DepartmentList>(authToken, "GET", queryString.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<Department> CreateDepartmentAsync(string authToken, string boxId, DepartmentToCreate departmentToCreate)
+		public Task<Department> CreateDepartmentAsync(string authToken, string boxId, DepartmentToCreate departmentToCreate, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/admin/CreateDepartment");
 			queryString.AddParameter("boxId", boxId);
-			return PerformHttpRequestAsync<DepartmentToCreate, Department>(authToken, queryString.BuildPathAndQuery(), departmentToCreate);
+			return PerformHttpRequestAsync<DepartmentToCreate, Department>(authToken, queryString.BuildPathAndQuery(), departmentToCreate, ct: ct);
 		}
 
-		public Task<Department> UpdateDepartmentAsync(string authToken, string boxId, string departmentId, DepartmentToUpdate departmentToUpdate)
+		public Task<Department> UpdateDepartmentAsync(string authToken, string boxId, string departmentId, DepartmentToUpdate departmentToUpdate, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/admin/UpdateDepartment");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("departmentId", departmentId);
-			return PerformHttpRequestAsync<DepartmentToUpdate, Department>(authToken, queryString.BuildPathAndQuery(), departmentToUpdate);
+			return PerformHttpRequestAsync<DepartmentToUpdate, Department>(authToken, queryString.BuildPathAndQuery(), departmentToUpdate, ct: ct);
 		}
 
-		public Task DeleteDepartmentAsync(string authToken, string boxId, string departmentId)
+		public Task DeleteDepartmentAsync(string authToken, string boxId, string departmentId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/admin/DeleteDepartment");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("departmentId", departmentId);
-			return PerformHttpRequestAsync(authToken, "Post", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync(authToken, "Post", queryString.BuildPathAndQuery(), ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.DetectCustomPrintForms.Async.cs b/src/DiadocHttpApi.DetectCustomPrintForms.Async.cs
index 01875c92..642a4c8b 100644
--- a/src/DiadocHttpApi.DetectCustomPrintForms.Async.cs
+++ b/src/DiadocHttpApi.DetectCustomPrintForms.Async.cs
@@ -1,3 +1,4 @@
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Proto;
 using JetBrains.Annotations;
@@ -6,13 +7,14 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<CustomPrintFormDetectionResult> DetectCustomPrintFormsAsync([NotNull] string authToken, [NotNull] string boxId, CustomPrintFormDetectionRequest request)
+		public Task<CustomPrintFormDetectionResult> DetectCustomPrintFormsAsync([NotNull] string authToken, [NotNull] string boxId, CustomPrintFormDetectionRequest request, CancellationToken ct = default)
 		{
 			var queryString = BuildQueryStringWithBoxId("DetectCustomPrintForms", boxId);
 			return PerformHttpRequestAsync<CustomPrintFormDetectionRequest, CustomPrintFormDetectionResult>(
 				authToken, 
 				queryString,
-				request);
+				request,
+				ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.DocflowAsync.cs b/src/DiadocHttpApi.DocflowAsync.cs
index 3351a2b8..57ee6982 100644
--- a/src/DiadocHttpApi.DocflowAsync.cs
+++ b/src/DiadocHttpApi.DocflowAsync.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Diadoc.Api.Proto.Docflow;
 using JetBrains.Annotations;
 
@@ -7,61 +8,61 @@ namespace Diadoc.Api
 	public partial class DiadocHttpApi
 	{
 		[ItemNotNull]
-		public Task<GetDocflowBatchResponse> GetDocflowsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowBatchRequest request)
+		public Task<GetDocflowBatchResponse> GetDocflowsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowBatchRequest request, CancellationToken ct = default)
 		{
 			var queryString = BuildQueryStringWithBoxId("/V2/GetDocflows", boxId);
-			return PerformHttpRequestAsync<GetDocflowBatchRequest, GetDocflowBatchResponse>(authToken, queryString, request);
+			return PerformHttpRequestAsync<GetDocflowBatchRequest, GetDocflowBatchResponse>(authToken, queryString, request, ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<GetDocflowEventsResponse> GetDocflowEventsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowEventsRequest request)
+		public Task<GetDocflowEventsResponse> GetDocflowEventsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowEventsRequest request, CancellationToken ct = default)
 		{
 			var queryString = BuildQueryStringWithBoxId("/V2/GetDocflowEvents", boxId);
-			return PerformHttpRequestAsync<GetDocflowEventsRequest, GetDocflowEventsResponse>(authToken, queryString, request);
+			return PerformHttpRequestAsync<GetDocflowEventsRequest, GetDocflowEventsResponse>(authToken, queryString, request, ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<SearchDocflowsResponse> SearchDocflowsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] SearchDocflowsRequest request)
+		public Task<SearchDocflowsResponse> SearchDocflowsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] SearchDocflowsRequest request, CancellationToken ct = default)
 		{
 			var queryString = BuildQueryStringWithBoxId("/V2/SearchDocflows", boxId);
-			return PerformHttpRequestAsync<SearchDocflowsRequest, SearchDocflowsResponse>(authToken, queryString, request);
+			return PerformHttpRequestAsync<SearchDocflowsRequest, SearchDocflowsResponse>(authToken, queryString, request, ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<GetDocflowsByPacketIdResponse> GetDocflowsByPacketIdAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowsByPacketIdRequest request)
+		public Task<GetDocflowsByPacketIdResponse> GetDocflowsByPacketIdAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowsByPacketIdRequest request, CancellationToken ct = default)
 		{
 			var queryString = BuildQueryStringWithBoxId("/V2/GetDocflowsByPacketId", boxId);
-			return PerformHttpRequestAsync<GetDocflowsByPacketIdRequest, GetDocflowsByPacketIdResponse>(authToken, queryString, request);
+			return PerformHttpRequestAsync<GetDocflowsByPacketIdRequest, GetDocflowsByPacketIdResponse>(authToken, queryString, request, ct: ct);
 		}
 
 		public partial class DocflowHttpApi
 		{
 			[ItemNotNull]
-			public Task<GetDocflowBatchResponseV3> GetDocflowsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowBatchRequest request)
+			public Task<GetDocflowBatchResponseV3> GetDocflowsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowBatchRequest request, CancellationToken ct = default)
 			{
 				var queryString = BuildQueryStringWithBoxId("/V3/GetDocflows", boxId);
-				return diadocHttpApi.PerformHttpRequestAsync<GetDocflowBatchRequest, GetDocflowBatchResponseV3>(authToken, queryString, request);
+				return diadocHttpApi.PerformHttpRequestAsync<GetDocflowBatchRequest, GetDocflowBatchResponseV3>(authToken, queryString, request, ct: ct);
 			}
 
 			[ItemNotNull]
-			public Task<GetDocflowEventsResponseV3> GetDocflowEventsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowEventsRequest request)
+			public Task<GetDocflowEventsResponseV3> GetDocflowEventsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowEventsRequest request, CancellationToken ct = default)
 			{
 				var queryString = BuildQueryStringWithBoxId("/V3/GetDocflowEvents", boxId);
-				return diadocHttpApi.PerformHttpRequestAsync<GetDocflowEventsRequest, GetDocflowEventsResponseV3>(authToken, queryString, request);
+				return diadocHttpApi.PerformHttpRequestAsync<GetDocflowEventsRequest, GetDocflowEventsResponseV3>(authToken, queryString, request, ct: ct);
 			}
 
 			[ItemNotNull]
-			public Task<SearchDocflowsResponseV3> SearchDocflowsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] SearchDocflowsRequest request)
+			public Task<SearchDocflowsResponseV3> SearchDocflowsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] SearchDocflowsRequest request, CancellationToken ct = default)
 			{
 				var queryString = BuildQueryStringWithBoxId("/V3/SearchDocflows", boxId);
-				return diadocHttpApi.PerformHttpRequestAsync<SearchDocflowsRequest, SearchDocflowsResponseV3>(authToken, queryString, request);
+				return diadocHttpApi.PerformHttpRequestAsync<SearchDocflowsRequest, SearchDocflowsResponseV3>(authToken, queryString, request, ct: ct);
 			}
 
 			[ItemNotNull]
-			public Task<GetDocflowsByPacketIdResponseV3> GetDocflowsByPacketIdAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowsByPacketIdRequest request)
+			public Task<GetDocflowsByPacketIdResponseV3> GetDocflowsByPacketIdAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetDocflowsByPacketIdRequest request, CancellationToken ct = default)
 			{
 				var queryString = BuildQueryStringWithBoxId("/V3/GetDocflowsByPacketId", boxId);
-				return diadocHttpApi.PerformHttpRequestAsync<GetDocflowsByPacketIdRequest, GetDocflowsByPacketIdResponseV3>(authToken, queryString, request);
+				return diadocHttpApi.PerformHttpRequestAsync<GetDocflowsByPacketIdRequest, GetDocflowsByPacketIdResponseV3>(authToken, queryString, request, ct: ct);
 			}
 		}
 	}
diff --git a/src/DiadocHttpApi.DocumentsAsync.cs b/src/DiadocHttpApi.DocumentsAsync.cs
index 921d2017..014f0c3d 100644
--- a/src/DiadocHttpApi.DocumentsAsync.cs
+++ b/src/DiadocHttpApi.DocumentsAsync.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Globalization;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto;
@@ -12,7 +13,7 @@ namespace Diadoc.Api
 	public partial class DiadocHttpApi
 	{
 		[ItemNotNull]
-		public Task<DocumentList> GetDocumentsAsync([NotNull] string authToken, [NotNull] DocumentsFilter filter)
+		public Task<DocumentList> GetDocumentsAsync([NotNull] string authToken, [NotNull] DocumentsFilter filter, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V3/GetDocuments");
 			qsb.AddParameter("boxId", filter.BoxId);
@@ -30,7 +31,7 @@ public Task<DocumentList> GetDocumentsAsync([NotNull] string authToken, [NotNull
 			if (!string.IsNullOrEmpty(filter.AfterIndexKey)) qsb.AddParameter("afterIndexKey", filter.AfterIndexKey);
 			if (!string.IsNullOrEmpty(filter.SortDirection)) qsb.AddParameter("sortDirection", filter.SortDirection);
 			if (filter.Count.HasValue) qsb.AddParameter("count", filter.Count.ToString());
-			return PerformHttpRequestAsync<DocumentList>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<DocumentList>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
 		[ItemNotNull]
@@ -43,7 +44,8 @@ public Task<DocumentList> GetDocumentsAsync(
 			[CanBeNull] string fromDocumentDate, [CanBeNull] string toDocumentDate,
 			[CanBeNull] string departmentId, bool excludeSubdepartments,
 			[CanBeNull] string afterIndexKey,
-			int? count = null
+			int? count = null,
+			CancellationToken ct = default
 		)
 		{
 			return GetDocumentsAsync(authToken, new DocumentsFilter
@@ -59,116 +61,116 @@ public Task<DocumentList> GetDocumentsAsync(
 				ExcludeSubdepartments = excludeSubdepartments,
 				AfterIndexKey = afterIndexKey,
 				Count = count
-			});
+			}, ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<Document> GetDocumentAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] string messageId, [NotNull] string entityId)
+		public Task<Document> GetDocumentAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] string messageId, [NotNull] string entityId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V3/GetDocument");
 			qsb.AddParameter("boxId", boxId);
 			qsb.AddParameter("messageId", messageId);
 			qsb.AddParameter("entityId", entityId);
-			return PerformHttpRequestAsync<Document>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<Document>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task DeleteAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] string messageId, [CanBeNull] string documentId)
+		public Task DeleteAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] string messageId, [CanBeNull] string documentId, CancellationToken ct = default)
 		{
-			return MessageOrDocumentCommandAsync("/Delete", authToken, boxId, messageId, documentId);
+			return MessageOrDocumentCommandAsync("/Delete", authToken, boxId, messageId, documentId, ct: ct);
 		}
 
-		public Task RestoreAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] string messageId, [CanBeNull] string documentId)
+		public Task RestoreAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] string messageId, [CanBeNull] string documentId, CancellationToken ct = default)
 		{
-			return MessageOrDocumentCommandAsync("/Restore", authToken, boxId, messageId, documentId);
+			return MessageOrDocumentCommandAsync("/Restore", authToken, boxId, messageId, documentId, ct: ct);
 		}
 
-		private Task MessageOrDocumentCommandAsync(string action, [NotNull] string authToken, [NotNull] string boxId, [NotNull] string messageId, [CanBeNull] string documentId)
+		private Task MessageOrDocumentCommandAsync(string action, [NotNull] string authToken, [NotNull] string boxId, [NotNull] string messageId, [CanBeNull] string documentId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder(action);
 			qsb.AddParameter("boxId", boxId);
 			qsb.AddParameter("messageId", messageId);
 			if (!string.IsNullOrEmpty(documentId)) qsb.AddParameter("documentId", documentId);
-			return PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task MoveDocumentsAsync([NotNull] string authToken, [NotNull] DocumentsMoveOperation query)
+		public Task MoveDocumentsAsync([NotNull] string authToken, [NotNull] DocumentsMoveOperation query, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/MoveDocuments");
-			return PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery(), Serialize(query));
+			return PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery(), Serialize(query), ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<DocumentList> GetDocumentsByCustomIdAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] string customDocumentId)
+		public Task<DocumentList> GetDocumentsByCustomIdAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] string customDocumentId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetDocumentsByCustomId");
 			qsb.AddParameter("boxId", boxId);
 			qsb.AddParameter("customDocumentId", customDocumentId);
-			return PerformHttpRequestAsync<DocumentList>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<DocumentList>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<DocumentList> GetDocumentsByMessageIdAsync(string authToken, string boxId, string messageId)
+		public Task<DocumentList> GetDocumentsByMessageIdAsync(string authToken, string boxId, string messageId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetDocumentsByMessageId");
 			qsb.AddParameter("boxId", boxId);
 			qsb.AddParameter("messageId", messageId);
-			return PerformHttpRequestAsync<DocumentList>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<DocumentList>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<SignatureInfo> GetSignatureInfoAsync(string authToken, string boxId, string messageId, string entityId)
+		public Task<SignatureInfo> GetSignatureInfoAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetSignatureInfo");
 			qsb.AddParameter("boxId", boxId);
 			qsb.AddParameter("messageId", messageId);
 			qsb.AddParameter("entityId", entityId);
-			return PerformHttpRequestAsync<SignatureInfo>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<SignatureInfo>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<ResolutionRouteList> GetResolutionRoutesForOrganizationAsync([NotNull] string authToken, [NotNull] string orgId)
+		public Task<ResolutionRouteList> GetResolutionRoutesForOrganizationAsync([NotNull] string authToken, [NotNull] string orgId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetResolutionRoutesForOrganization");
 			qsb.AddParameter("orgId", orgId);
-			return PerformHttpRequestAsync<ResolutionRouteList>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<ResolutionRouteList>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<GetDocumentTypesResponse> GetDocumentTypesAsync(string authToken, string boxId)
+		public Task<GetDocumentTypesResponse> GetDocumentTypesAsync(string authToken, string boxId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetDocumentTypes");
 			qsb.AddParameter("boxId", boxId);
-			return PerformHttpRequestAsync<GetDocumentTypesResponse>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<GetDocumentTypesResponse>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, string nameOnShelf)
+		public Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, string nameOnShelf, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/DetectDocumentTypes");
 			qsb.AddParameter("boxId", boxId);
 			qsb.AddParameter("nameOnShelf", nameOnShelf);
-			return PerformHttpRequestAsync<DetectDocumentTypesResponse>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<DetectDocumentTypesResponse>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, byte[] content)
+		public Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, byte[] content, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/DetectDocumentTypes");
 			qsb.AddParameter("boxId", boxId);
-			return PerformHttpRequestAsync<DetectDocumentTypesResponse>(authToken, "POST", qsb.BuildPathAndQuery(), content);
+			return PerformHttpRequestAsync<DetectDocumentTypesResponse>(authToken, "POST", qsb.BuildPathAndQuery(), content, ct: ct);
 		}
 		
-		public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, string nameOnShelf)
+		public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, string nameOnShelf, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/DetectDocumentTitles");
 			qsb.AddParameter("boxId", boxId);
 			qsb.AddParameter("nameOnShelf", nameOnShelf);
-			return PerformHttpRequestAsync<DetectTitleResponse>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<DetectTitleResponse>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, byte[] content)
+		public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, byte[] content, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/DetectDocumentTitles");
 			qsb.AddParameter("boxId", boxId);
-			return PerformHttpRequestAsync<DetectTitleResponse>(authToken, "POST", qsb.BuildPathAndQuery(), content);
+			return PerformHttpRequestAsync<DetectTitleResponse>(authToken, "POST", qsb.BuildPathAndQuery(), content, ct: ct);
 		}
 
-		public async Task<FileContent> GetContentAsync(string authToken, string typeNamedId, string function, string version, int titleIndex, XsdContentType contentType = default(XsdContentType))
+		public async Task<FileContent> GetContentAsync(string authToken, string typeNamedId, string function, string version, int titleIndex, XsdContentType contentType = default(XsdContentType), CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetContent");
 			qsb.AddParameter("typeNamedId", typeNamedId);
@@ -178,7 +180,7 @@ public Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, str
 			qsb.AddParameter("contentType", contentType.ToString());
 
 			var request = BuildHttpRequest(authToken, "GET", qsb.BuildPathAndQuery(), null);
-			var response = await HttpClient.PerformHttpRequestAsync(request).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct).ConfigureAwait(false);
 
 			return new FileContent(response.Content, response.ContentDispositionFileName);
 		}
diff --git a/src/DiadocHttpApi.DraftsAsync.cs b/src/DiadocHttpApi.DraftsAsync.cs
index 14c997b2..012da4c5 100644
--- a/src/DiadocHttpApi.DraftsAsync.cs
+++ b/src/DiadocHttpApi.DraftsAsync.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Events;
 
@@ -6,20 +7,20 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task RecycleDraftAsync(string authToken, string boxId, string draftId)
+		public Task RecycleDraftAsync(string authToken, string boxId, string draftId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/RecycleDraft");
 			qsb.AddParameter("boxId", boxId);
 			if (!string.IsNullOrEmpty(draftId))
 				qsb.AddParameter("draftId", draftId);
-			return PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<Message> SendDraftAsync(string authToken, DraftToSend draft, string operationId = null)
+		public Task<Message> SendDraftAsync(string authToken, DraftToSend draft, string operationId = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/SendDraft");
 			qsb.AddParameter("operationId", operationId);
-			return PerformHttpRequestAsync<DraftToSend, Message>(authToken, qsb.BuildPathAndQuery(), draft);
+			return PerformHttpRequestAsync<DraftToSend, Message>(authToken, qsb.BuildPathAndQuery(), draft, ct: ct);
 		}
 	}
 }
diff --git a/src/DiadocHttpApi.Employees.Async.cs b/src/DiadocHttpApi.Employees.Async.cs
index d44ce399..344bf2b0 100644
--- a/src/DiadocHttpApi.Employees.Async.cs
+++ b/src/DiadocHttpApi.Employees.Async.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Employees;
 using Diadoc.Api.Proto.Employees.Subscriptions;
@@ -7,67 +8,67 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<Employee> GetEmployeeAsync(string authToken, string boxId, string userId)
+		public Task<Employee> GetEmployeeAsync(string authToken, string boxId, string userId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/GetEmployee");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("userId", userId);
-			return PerformHttpRequestAsync<Employee>(authToken, "GET", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<Employee>(authToken, "GET", queryString.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<EmployeeList> GetEmployeesAsync(string authToken, string boxId, int? page, int? count)
+		public Task<EmployeeList> GetEmployeesAsync(string authToken, string boxId, int? page, int? count, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/GetEmployees");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("page", page.ToString());
 			queryString.AddParameter("count", count.ToString());
-			return PerformHttpRequestAsync<EmployeeList>(authToken, "GET", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<EmployeeList>(authToken, "GET", queryString.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<Employee> CreateEmployeeAsync(string authToken, string boxId, EmployeeToCreate employeeToCreate)
+		public Task<Employee> CreateEmployeeAsync(string authToken, string boxId, EmployeeToCreate employeeToCreate, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/CreateEmployee");
 			queryString.AddParameter("boxId", boxId);
-			return PerformHttpRequestAsync<EmployeeToCreate, Employee>(authToken, queryString.BuildPathAndQuery(), employeeToCreate);
+			return PerformHttpRequestAsync<EmployeeToCreate, Employee>(authToken, queryString.BuildPathAndQuery(), employeeToCreate, ct: ct);
 		}
 
-		public Task<Employee> UpdateEmployeeAsync(string authToken, string boxId, string userId, EmployeeToUpdate employeeToUpdate)
+		public Task<Employee> UpdateEmployeeAsync(string authToken, string boxId, string userId, EmployeeToUpdate employeeToUpdate, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/UpdateEmployee");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("userId", userId);
-			return PerformHttpRequestAsync<EmployeeToUpdate, Employee>(authToken, queryString.BuildPathAndQuery(), employeeToUpdate);
+			return PerformHttpRequestAsync<EmployeeToUpdate, Employee>(authToken, queryString.BuildPathAndQuery(), employeeToUpdate, ct: ct);
 		}
 
-		public Task DeleteEmployeeAsync(string authToken, string boxId, string userId)
+		public Task DeleteEmployeeAsync(string authToken, string boxId, string userId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/DeleteEmployee");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("userId", userId);
-			return PerformHttpRequestAsync(authToken, "POST", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync(authToken, "POST", queryString.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<EmployeeSubscriptions> GetSubscriptionsAsync(string authToken, string boxId, string userId)
+		public Task<EmployeeSubscriptions> GetSubscriptionsAsync(string authToken, string boxId, string userId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/GetSubscriptions");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("userId", userId);
-			return PerformHttpRequestAsync<EmployeeSubscriptions>(authToken, "GET", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<EmployeeSubscriptions>(authToken, "GET", queryString.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<EmployeeSubscriptions> UpdateSubscriptionsAsync(string authToken, string boxId, string userId, SubscriptionsToUpdate subscriptionsToUpdate)
+		public Task<EmployeeSubscriptions> UpdateSubscriptionsAsync(string authToken, string boxId, string userId, SubscriptionsToUpdate subscriptionsToUpdate, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/UpdateSubscriptions");
 			queryString.AddParameter("boxId", boxId);
 			queryString.AddParameter("userId", userId);
-			return PerformHttpRequestAsync<SubscriptionsToUpdate, EmployeeSubscriptions>(authToken, queryString.BuildPathAndQuery(), subscriptionsToUpdate);
+			return PerformHttpRequestAsync<SubscriptionsToUpdate, EmployeeSubscriptions>(authToken, queryString.BuildPathAndQuery(), subscriptionsToUpdate, ct: ct);
 		}
 
-		public Task<Employee> GetMyEmployeeAsync(string authToken, string boxId)
+		public Task<Employee> GetMyEmployeeAsync(string authToken, string boxId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/GetMyEmployee");
 			queryString.AddParameter("boxId", boxId);
-			return PerformHttpRequestAsync<Employee>(authToken, "GET", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<Employee>(authToken, "GET", queryString.BuildPathAndQuery(), ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.EventsAsync.cs b/src/DiadocHttpApi.EventsAsync.cs
index e28bc509..8358970a 100644
--- a/src/DiadocHttpApi.EventsAsync.cs
+++ b/src/DiadocHttpApi.EventsAsync.cs
@@ -1,4 +1,5 @@
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Events;
@@ -8,24 +9,24 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<BoxEventList> GetNewEventsAsync(string authToken, string boxId, string afterEventId = null)
+		public Task<BoxEventList> GetNewEventsAsync(string authToken, string boxId, string afterEventId = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V5/GetNewEvents");
 			qsb.AddParameter("includeDrafts");
 			qsb.AddParameter("boxId", boxId);
 			if (!string.IsNullOrEmpty(afterEventId)) qsb.AddParameter("afterEventId", afterEventId);
-			return PerformHttpRequestAsync<BoxEventList>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<BoxEventList>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<BoxEvent> GetEventAsync(string authToken, string boxId, string eventId)
+		public Task<BoxEvent> GetEventAsync(string authToken, string boxId, string eventId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V2/GetEvent");
 			qsb.AddParameter("eventId", eventId);
 			qsb.AddParameter("boxId", boxId);
-			return PerformHttpRequestAsync<BoxEvent>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<BoxEvent>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, bool withOriginalSignature = false, bool injectEntityContent = false)
+		public Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, bool withOriginalSignature = false, bool injectEntityContent = false, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V4/GetMessage");
 			qsb.AddParameter("boxId", boxId);
@@ -33,10 +34,10 @@ public Task<Message> GetMessageAsync(string authToken, string boxId, string mess
 			if (withOriginalSignature)
 				qsb.AddParameter("originalSignature");
 			qsb.AddParameter("injectEntityContent", injectEntityContent.ToString());
-			return PerformHttpRequestAsync<Message>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<Message>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, string entityId, bool withOriginalSignature = false, bool injectEntityContent = false)
+		public Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, string entityId, bool withOriginalSignature = false, bool injectEntityContent = false, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V4/GetMessage");
 			qsb.AddParameter("boxId", boxId);
@@ -45,10 +46,10 @@ public Task<Message> GetMessageAsync(string authToken, string boxId, string mess
 			if (withOriginalSignature)
 				qsb.AddParameter("originalSignature");
 			qsb.AddParameter("injectEntityContent", injectEntityContent.ToString());
-			return PerformHttpRequestAsync<Message>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<Message>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<Template> GetTemplateAsync(string authToken, string boxId, string templateId, string entityId = null)
+		public Task<Template> GetTemplateAsync(string authToken, string boxId, string templateId, string entityId = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetTemplate");
 			qsb.AddParameter("boxId", boxId);
@@ -59,45 +60,45 @@ public Task<Template> GetTemplateAsync(string authToken, string boxId, string te
 				qsb.AddParameter("entityId", entityId);
 			}
 
-			return PerformHttpRequestAsync<Template>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<Template>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<byte[]> GetEntityContentAsync(string authToken, string boxId, string messageId, string entityId)
+		public Task<byte[]> GetEntityContentAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V4/GetEntityContent");
 			qsb.AddParameter("boxId", boxId);
 			qsb.AddParameter("messageId", messageId);
 			qsb.AddParameter("entityId", entityId);
-			return PerformHttpRequestAsync(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<Message> PostMessageAsync(string authToken, MessageToPost msg, string operationId = null)
+		public Task<Message> PostMessageAsync(string authToken, MessageToPost msg, string operationId = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V3/PostMessage");
 			qsb.AddParameter("operationId", operationId);
-			return PerformHttpRequestAsync<MessageToPost, Message>(authToken, qsb.BuildPathAndQuery(), msg);
+			return PerformHttpRequestAsync<MessageToPost, Message>(authToken, qsb.BuildPathAndQuery(), msg, ct: ct);
 		}
 
-		public Task<Template> PostTemplateAsync(string authToken, TemplateToPost template, string operationId = null)
+		public Task<Template> PostTemplateAsync(string authToken, TemplateToPost template, string operationId = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/PostTemplate");
 			qsb.AddParameter("operationId", operationId);
-			return PerformHttpRequestAsync<TemplateToPost, Template>(authToken, qsb.BuildPathAndQuery(), template);
+			return PerformHttpRequestAsync<TemplateToPost, Template>(authToken, qsb.BuildPathAndQuery(), template, ct: ct);
 		}
 
-		public Task<Message> TransformTemplateToMessageAsync(string authToken, TemplateTransformationToPost templateTransformation, string operationId = null)
+		public Task<Message> TransformTemplateToMessageAsync(string authToken, TemplateTransformationToPost templateTransformation, string operationId = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/TransformTemplateToMessage");
 			qsb.AddParameter("operationId", operationId);
 
-			return PerformHttpRequestAsync<TemplateTransformationToPost, Message>(authToken, qsb.BuildPathAndQuery(), templateTransformation);
+			return PerformHttpRequestAsync<TemplateTransformationToPost, Message>(authToken, qsb.BuildPathAndQuery(), templateTransformation, ct: ct);
 		}
 
-		public Task<MessagePatch> PostMessagePatchAsync(string authToken, MessagePatchToPost patch, string operationId = null)
+		public Task<MessagePatch> PostMessagePatchAsync(string authToken, MessagePatchToPost patch, string operationId = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V3/PostMessagePatch");
 			qsb.AddParameter("operationId", operationId);
-			return PerformHttpRequestAsync<MessagePatchToPost, MessagePatch>(authToken, qsb.BuildPathAndQuery(), patch);
+			return PerformHttpRequestAsync<MessagePatchToPost, MessagePatch>(authToken, qsb.BuildPathAndQuery(), patch, ct: ct);
 		}
 
 		public Task<MessagePatch> PostTemplatePatchAsync(
@@ -105,31 +106,32 @@ public Task<MessagePatch> PostTemplatePatchAsync(
 			string boxId,
 			string templateId,
 			TemplatePatchToPost patch,
-			string operationId = null)
+			string operationId = null, 
+			CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/PostTemplatePatch");
 			qsb.AddParameter("boxId", boxId);
 			qsb.AddParameter("templateId", templateId);
 			qsb.AddParameter("operationId", operationId);
-			return PerformHttpRequestAsync<TemplatePatchToPost, MessagePatch>(authToken, qsb.BuildPathAndQuery(), patch);
+			return PerformHttpRequestAsync<TemplatePatchToPost, MessagePatch>(authToken, qsb.BuildPathAndQuery(), patch, ct: ct);
 		}
 
-		public Task PostRoamingNotificationAsync(string authToken, RoamingNotificationToPost notification)
+		public Task PostRoamingNotificationAsync(string authToken, RoamingNotificationToPost notification, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync(authToken, "POST", "/PostRoamingNotification", Serialize(notification));
+			return PerformHttpRequestAsync(authToken, "POST", "/PostRoamingNotification", Serialize(notification), ct: ct);
 		}
 
-		public Task<PrepareDocumentsToSignResponse> PrepareDocumentsToSignAsync(string authToken, PrepareDocumentsToSignRequest request, bool excludeContent = false)
+		public Task<PrepareDocumentsToSignResponse> PrepareDocumentsToSignAsync(string authToken, PrepareDocumentsToSignRequest request, bool excludeContent = false, CancellationToken ct = default)
 		{
 			var queryString = "/PrepareDocumentsToSign" + (excludeContent ? "?excludeContent" : "");
-			return PerformHttpRequestAsync<PrepareDocumentsToSignRequest, PrepareDocumentsToSignResponse>(authToken, queryString, request);
+			return PerformHttpRequestAsync<PrepareDocumentsToSignRequest, PrepareDocumentsToSignResponse>(authToken, queryString, request, ct: ct);
 		}
 		
 		[NotNull]
-		public Task<BoxEvent> GetLastEventAsync([NotNull] string authToken, [NotNull] string boxId)
+		public Task<BoxEvent> GetLastEventAsync([NotNull] string authToken, [NotNull] string boxId, CancellationToken ct = default)
 		{
 			var queryString = BuildQueryStringWithBoxId("GetLastEvent", boxId);
-			return PerformHttpRequestAsync<BoxEvent>(authToken,"GET", queryString, allowStatusCodes: HttpStatusCode.NoContent);
+			return PerformHttpRequestAsync<BoxEvent>(authToken,"GET", queryString, allowStatusCodes: HttpStatusCode.NoContent, ct: ct);
 		}
 	}
 }
diff --git a/src/DiadocHttpApi.ExternalServicesAsync.cs b/src/DiadocHttpApi.ExternalServicesAsync.cs
index 9e153da1..b1387324 100644
--- a/src/DiadocHttpApi.ExternalServicesAsync.cs
+++ b/src/DiadocHttpApi.ExternalServicesAsync.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto;
 
@@ -6,11 +7,11 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<ExternalServiceAuthInfo> GetExternalServiceAuthInfoAsync(string key)
+		public Task<ExternalServiceAuthInfo> GetExternalServiceAuthInfoAsync(string key, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetExternalServiceAuthInfo");
 			qsb.AddParameter("key", key);
-			return PerformHttpRequestAsync<ExternalServiceAuthInfo>(null, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<ExternalServiceAuthInfo>(null, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 	}
 }
diff --git a/src/DiadocHttpApi.ForwardingAsync.cs b/src/DiadocHttpApi.ForwardingAsync.cs
index b932a08f..fddea354 100644
--- a/src/DiadocHttpApi.ForwardingAsync.cs
+++ b/src/DiadocHttpApi.ForwardingAsync.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Documents;
 using Diadoc.Api.Proto.Forwarding;
@@ -9,56 +10,56 @@ namespace Diadoc.Api
 	public partial class DiadocHttpApi
 	{
 		[ItemNotNull]
-		public Task<ForwardDocumentResponse> ForwardDocumentAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] ForwardDocumentRequest request)
+		public Task<ForwardDocumentResponse> ForwardDocumentAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] ForwardDocumentRequest request, CancellationToken ct = default)
 		{
 			var queryString = BuildQueryStringWithBoxId("/V2/ForwardDocument", boxId);
-			return PerformHttpRequestAsync<ForwardDocumentRequest, ForwardDocumentResponse>(authToken, queryString, request);
+			return PerformHttpRequestAsync<ForwardDocumentRequest, ForwardDocumentResponse>(authToken, queryString, request, ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<GetForwardedDocumentsResponse> GetForwardedDocumentsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetForwardedDocumentsRequest request)
+		public Task<GetForwardedDocumentsResponse> GetForwardedDocumentsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetForwardedDocumentsRequest request, CancellationToken ct = default)
 		{
 			var queryString = BuildQueryStringWithBoxId("/V2/GetForwardedDocuments", boxId);
-			return PerformHttpRequestAsync<GetForwardedDocumentsRequest, GetForwardedDocumentsResponse>(authToken, queryString, request);
+			return PerformHttpRequestAsync<GetForwardedDocumentsRequest, GetForwardedDocumentsResponse>(authToken, queryString, request, ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<GetForwardedDocumentEventsResponse> GetForwardedDocumentEventsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetForwardedDocumentEventsRequest request)
+		public Task<GetForwardedDocumentEventsResponse> GetForwardedDocumentEventsAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] GetForwardedDocumentEventsRequest request, CancellationToken ct = default)
 		{
 			var queryString = BuildQueryStringWithBoxId("/V2/GetForwardedDocumentEvents", boxId);
-			return PerformHttpRequestAsync<GetForwardedDocumentEventsRequest, GetForwardedDocumentEventsResponse>(authToken, queryString, request);
+			return PerformHttpRequestAsync<GetForwardedDocumentEventsRequest, GetForwardedDocumentEventsResponse>(authToken, queryString, request, ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<byte[]> GetForwardedEntityContentAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] ForwardedDocumentId forwardedDocumentId, [NotNull] string entityId)
+		public Task<byte[]> GetForwardedEntityContentAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] ForwardedDocumentId forwardedDocumentId, [NotNull] string entityId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/V2/GetForwardedEntityContent")
 				.WithBoxId(boxId)
 				.WithForwardedDocumentId(forwardedDocumentId)
 				.With("entityId", entityId)
 				.BuildPathAndQuery();
-			return PerformHttpRequestAsync(authToken, "GET", queryString);
+			return PerformHttpRequestAsync(authToken, "GET", queryString, ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<DocumentProtocolResult> GenerateForwardedDocumentProtocolAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] ForwardedDocumentId forwardedDocumentId)
+		public Task<DocumentProtocolResult> GenerateForwardedDocumentProtocolAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] ForwardedDocumentId forwardedDocumentId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/V2/GenerateForwardedDocumentProtocol")
 				.WithBoxId(boxId)
 				.WithForwardedDocumentId(forwardedDocumentId)
 				.BuildPathAndQuery();
 			var request = BuildHttpRequest(authToken, "GET", queryString, null);
-			return GenerateDocumentProtocolAsync(request);
+			return GenerateDocumentProtocolAsync(request, ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<PrintFormResult> GenerateForwardedDocumentPrintFormAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] ForwardedDocumentId forwardedDocumentId)
+		public Task<PrintFormResult> GenerateForwardedDocumentPrintFormAsync([NotNull] string authToken, [NotNull] string boxId, [NotNull] ForwardedDocumentId forwardedDocumentId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/GenerateForwardedDocumentPrintForm")
 				.WithBoxId(boxId)
 				.WithForwardedDocumentId(forwardedDocumentId)
 				.BuildPathAndQuery();
-			return GetPrintFormResultAsync(authToken, queryString);
+			return GetPrintFormResultAsync(authToken, queryString, ct: ct);
 		}
 	}
 }
diff --git a/src/DiadocHttpApi.InvoicingAsync.cs b/src/DiadocHttpApi.InvoicingAsync.cs
index 85027068..8cb373ff 100644
--- a/src/DiadocHttpApi.InvoicingAsync.cs
+++ b/src/DiadocHttpApi.InvoicingAsync.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Net;
 using System.Security.Cryptography.X509Certificates;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Events;
@@ -12,126 +13,126 @@ namespace Diadoc.Api
 	public partial class DiadocHttpApi
 	{
 		[Obsolete("Use GenerateReceiptXmlAsync()")]
-		public Task<GeneratedFile> GenerateInvoiceDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer)
+		public Task<GeneratedFile> GenerateInvoiceDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer, CancellationToken ct = default)
 		{
 			var queryString = $"/GenerateInvoiceDocumentReceiptXml?boxId={boxId}&messageId={messageId}&attachmentId={attachmentId}";
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, signer);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, signer, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateInvoiceCorrectionRequestXmlAsync(string authToken, string boxId, string messageId, string attachmentId, InvoiceCorrectionRequestInfo correctionInfo)
+		public Task<GeneratedFile> GenerateInvoiceCorrectionRequestXmlAsync(string authToken, string boxId, string messageId, string attachmentId, InvoiceCorrectionRequestInfo correctionInfo, CancellationToken ct = default)
 		{
 			var queryString = $"/GenerateInvoiceCorrectionRequestXml?boxId={boxId}&messageId={messageId}&attachmentId={attachmentId}";
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, correctionInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, correctionInfo, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateRevocationRequestXmlAsync(string authToken, string boxId, string messageId, string attachmentId, RevocationRequestInfo revocationRequestInfo)
+		public Task<GeneratedFile> GenerateRevocationRequestXmlAsync(string authToken, string boxId, string messageId, string attachmentId, RevocationRequestInfo revocationRequestInfo, CancellationToken ct = default)
 		{
 			var queryString = $"/GenerateRevocationRequestXml?boxId={boxId}&messageId={messageId}&attachmentId={attachmentId}";
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, revocationRequestInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, revocationRequestInfo, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateSignatureRejectionXmlAsync(string authToken, string boxId, string messageId, string attachmentId, SignatureRejectionInfo signatureRejectionInfo)
+		public Task<GeneratedFile> GenerateSignatureRejectionXmlAsync(string authToken, string boxId, string messageId, string attachmentId, SignatureRejectionInfo signatureRejectionInfo, CancellationToken ct = default)
 		{
 			var queryString = $"/GenerateSignatureRejectionXml?boxId={boxId}&messageId={messageId}&attachmentId={attachmentId}";
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, signatureRejectionInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, signatureRejectionInfo, ct: ct);
 		}
 
-		public Task<InvoiceCorrectionRequestInfo> GetInvoiceCorrectionRequestInfoAsync(string authToken, string boxId, string messageId, string entityId)
+		public Task<InvoiceCorrectionRequestInfo> GetInvoiceCorrectionRequestInfoAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default)
 		{
 			var queryString = $"/GetInvoiceCorrectionRequestInfo?boxId={boxId}&messageId={messageId}&entityId={entityId}";
-			return PerformHttpRequestAsync<InvoiceCorrectionRequestInfo>(authToken, "GET", queryString);
+			return PerformHttpRequestAsync<InvoiceCorrectionRequestInfo>(authToken, "GET", queryString, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateInvoiceXmlAsync(string authToken, InvoiceInfo invoiceInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateInvoiceXmlAsync(string authToken, InvoiceInfo invoiceInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
-			return GenerateInvoiceXmlAsync(authToken, invoiceInfo, "Invoice", disableValidation);
+			return GenerateInvoiceXmlAsync(authToken, invoiceInfo, "Invoice", disableValidation, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateInvoiceRevisionXmlAsync(string authToken, InvoiceInfo invoiceRevisionInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateInvoiceRevisionXmlAsync(string authToken, InvoiceInfo invoiceRevisionInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
-			return GenerateInvoiceXmlAsync(authToken, invoiceRevisionInfo, "InvoiceRevision", disableValidation);
+			return GenerateInvoiceXmlAsync(authToken, invoiceRevisionInfo, "InvoiceRevision", disableValidation, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateInvoiceCorrectionXmlAsync(string authToken, InvoiceCorrectionInfo invoiceCorrectionInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateInvoiceCorrectionXmlAsync(string authToken, InvoiceCorrectionInfo invoiceCorrectionInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
-			return GenerateInvoiceXmlAsync(authToken, invoiceCorrectionInfo, "InvoiceCorrection", disableValidation);
+			return GenerateInvoiceXmlAsync(authToken, invoiceCorrectionInfo, "InvoiceCorrection", disableValidation, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateInvoiceCorrectionRevisionXmlAsync(string authToken, InvoiceCorrectionInfo invoiceCorrectionRevision, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateInvoiceCorrectionRevisionXmlAsync(string authToken, InvoiceCorrectionInfo invoiceCorrectionRevision, bool disableValidation = false, CancellationToken ct = default)
 		{
-			return GenerateInvoiceXmlAsync(authToken, invoiceCorrectionRevision, "InvoiceCorrectionRevision", disableValidation);
+			return GenerateInvoiceXmlAsync(authToken, invoiceCorrectionRevision, "InvoiceCorrectionRevision", disableValidation, ct: ct);
 		}
 
-		private Task<GeneratedFile> GenerateInvoiceXmlAsync<T>(string authToken, T protoInvoice, string invoiceType, bool disableValidation = false) where T : class
+		private Task<GeneratedFile> GenerateInvoiceXmlAsync<T>(string authToken, T protoInvoice, string invoiceType, bool disableValidation = false, CancellationToken ct = default) where T : class
 		{
 			var qsb = new PathAndQueryBuilder("/GenerateInvoiceXml").With("invoiceType", invoiceType);
 			if (disableValidation)
 				qsb.AddParameter("disableValidation");
-			return PerformGenerateXmlHttpRequestAsync(authToken, qsb.BuildPathAndQuery(), protoInvoice);
+			return PerformGenerateXmlHttpRequestAsync(authToken, qsb.BuildPathAndQuery(), protoInvoice, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateTorg12XmlForSellerAsync(string authToken, Torg12SellerTitleInfo sellerInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateTorg12XmlForSellerAsync(string authToken, Torg12SellerTitleInfo sellerInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GenerateTorg12XmlForSeller");
 			if (disableValidation) queryBuilder.AddParameter("disableValidation");
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), sellerInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), sellerInfo, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateTovTorg551XmlForSellerAsync(string authToken, TovTorgSellerTitleInfo sellerInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateTovTorg551XmlForSellerAsync(string authToken, TovTorgSellerTitleInfo sellerInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GenerateTorg12XmlForSeller");
 			if (disableValidation) queryBuilder.AddParameter("disableValidation");
 			queryBuilder.AddParameter("documentVersion", DefaultDocumentVersions.TovTorg551);
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), sellerInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), sellerInfo, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateTorg12XmlForBuyerAsync(string authToken, Torg12BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId)
+		public Task<GeneratedFile> GenerateTorg12XmlForBuyerAsync(string authToken, Torg12BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GenerateTorg12XmlForBuyer");
 			queryBuilder.AddParameter("boxId", boxId);
 			queryBuilder.AddParameter("sellerTitleMessageId", sellerTitleMessageId);
 			queryBuilder.AddParameter("sellerTitleAttachmentId", sellerTitleAttachmentId);
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), buyerInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), buyerInfo, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateTovTorg551XmlForBuyerAsync(string authToken, TovTorgBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, string documentVersion = null)
+		public Task<GeneratedFile> GenerateTovTorg551XmlForBuyerAsync(string authToken, TovTorgBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, string documentVersion = null, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GenerateTorg12XmlForBuyer");
 			queryBuilder.AddParameter("boxId", boxId);
 			queryBuilder.AddParameter("sellerTitleMessageId", sellerTitleMessageId);
 			queryBuilder.AddParameter("sellerTitleAttachmentId", sellerTitleAttachmentId);
 			queryBuilder.AddParameter("documentVersion", documentVersion ?? DefaultDocumentVersions.TovTorg551);
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), buyerInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), buyerInfo, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateAcceptanceCertificateXmlForSellerAsync(string authToken, AcceptanceCertificateSellerTitleInfo sellerInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateAcceptanceCertificateXmlForSellerAsync(string authToken, AcceptanceCertificateSellerTitleInfo sellerInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
 			var queryString = string.Format("/GenerateAcceptanceCertificateXmlForSeller{0}", disableValidation ? "?disableValidation" : "");
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, sellerInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, sellerInfo, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateAcceptanceCertificateXmlForBuyerAsync(string authToken, AcceptanceCertificateBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId)
+		public Task<GeneratedFile> GenerateAcceptanceCertificateXmlForBuyerAsync(string authToken, AcceptanceCertificateBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default)
 		{
 			var queryString = string.Format("/GenerateAcceptanceCertificateXmlForBuyer?boxId={0}&sellerTitleMessageId={1}&sellerTitleAttachmentId={2}", boxId, sellerTitleMessageId, sellerTitleAttachmentId);
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, buyerInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, buyerInfo, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForSellerAsync(string authToken, AcceptanceCertificate552SellerTitleInfo sellerInfo, bool disableValidation = false)
+		public Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForSellerAsync(string authToken, AcceptanceCertificate552SellerTitleInfo sellerInfo, bool disableValidation = false, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GenerateAcceptanceCertificateXmlForSeller");
 			if (disableValidation) queryBuilder.AddParameter("disableValidation");
 			queryBuilder.AddParameter("documentVersion", DefaultDocumentVersions.AcceptanceCerttificate552);
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), sellerInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), sellerInfo, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForBuyerAsync(string authToken, AcceptanceCertificate552BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId)
+		public Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForBuyerAsync(string authToken, AcceptanceCertificate552BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GenerateAcceptanceCertificateXmlForBuyer");
 			queryBuilder.AddParameter("boxId", boxId);
 			queryBuilder.AddParameter("sellerTitleMessageId", sellerTitleMessageId);
 			queryBuilder.AddParameter("sellerTitleAttachmentId", sellerTitleAttachmentId);
 			queryBuilder.AddParameter("documentVersion", DefaultDocumentVersions.AcceptanceCerttificate552);
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), buyerInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryBuilder.BuildPathAndQuery(), buyerInfo, ct: ct);
 		}
 
 		public async Task<GeneratedFile> GenerateTitleXmlAsync(
@@ -145,7 +146,8 @@ public async Task<GeneratedFile> GenerateTitleXmlAsync(
 			bool disableValidation = false,
 			string editingSettingId = null,
 			string letterId = null,
-			string documentId = null)
+			string documentId = null,
+			CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GenerateTitleXml");
 			queryBuilder.AddParameter("boxId", boxId);
@@ -159,11 +161,11 @@ public async Task<GeneratedFile> GenerateTitleXmlAsync(
 			queryBuilder.AddParameter("documentId", documentId);
 
 			var request = BuildHttpRequest(authToken, "POST", queryBuilder.BuildPathAndQuery(), userContractData);
-			var response = await HttpClient.PerformHttpRequestAsync(request).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct).ConfigureAwait(false);
 			return new GeneratedFile(response.ContentDispositionFileName, response.Content);
 		}
 
-		public async Task<GeneratedFile> GenerateSenderTitleXmlAsync(string authToken, string boxId, string documentTypeNamedId, string documentFunction, string documentVersion, byte[] userContractData, bool disableValidation = false, string editingSettingId = null)
+		public async Task<GeneratedFile> GenerateSenderTitleXmlAsync(string authToken, string boxId, string documentTypeNamedId, string documentFunction, string documentVersion, byte[] userContractData, bool disableValidation = false, string editingSettingId = null, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GenerateSenderTitleXml");
 			queryBuilder.AddParameter("boxId", boxId);
@@ -174,11 +176,11 @@ public async Task<GeneratedFile> GenerateSenderTitleXmlAsync(string authToken, s
 			if (disableValidation) queryBuilder.AddParameter("disableValidation");
 
 			var request = BuildHttpRequest(authToken, "POST", queryBuilder.BuildPathAndQuery(), userContractData);
-			var response = await HttpClient.PerformHttpRequestAsync(request).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct).ConfigureAwait(false);
 			return new GeneratedFile(response.ContentDispositionFileName, response.Content);
 		}
 
-		public async Task<GeneratedFile> GenerateRecipientTitleXmlAsync(string authToken, string boxId, string senderTitleMessageId, string senderTitleAttachmentId, byte[] userContractData, string documentVersion = null)
+		public async Task<GeneratedFile> GenerateRecipientTitleXmlAsync(string authToken, string boxId, string senderTitleMessageId, string senderTitleAttachmentId, byte[] userContractData, string documentVersion = null, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GenerateRecipientTitleXml");
 			queryBuilder.AddParameter("boxId", boxId);
@@ -187,91 +189,91 @@ public async Task<GeneratedFile> GenerateRecipientTitleXmlAsync(string authToken
 			queryBuilder.AddParameter("documentVersion", documentVersion);
 
 			var request = BuildHttpRequest(authToken, "POST", queryBuilder.BuildPathAndQuery(), userContractData);
-			var response = await HttpClient.PerformHttpRequestAsync(request).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct).ConfigureAwait(false);
 			return new GeneratedFile(response.ContentDispositionFileName, response.Content);
 		}
 
-		public async Task<bool> CanSendInvoiceAsync(string authToken, string boxId, byte[] certificateBytes)
+		public async Task<bool> CanSendInvoiceAsync(string authToken, string boxId, byte[] certificateBytes, CancellationToken ct = default)
 		{
 			var queryString = string.Format("/CanSendInvoice?boxId={0}", boxId);
 			var request = BuildHttpRequest(authToken, "POST", queryString, certificateBytes);
-			var response = await HttpClient.PerformHttpRequestAsync(request, HttpStatusCode.Forbidden).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct, HttpStatusCode.Forbidden).ConfigureAwait(false);
 			return response.StatusCode == HttpStatusCode.OK;
 		}
 
-		public Task SendFnsRegistrationMessageAsync(string authToken, string boxId, FnsRegistrationMessageInfo fnsRegistrationMessageInfo)
+		public Task SendFnsRegistrationMessageAsync(string authToken, string boxId, FnsRegistrationMessageInfo fnsRegistrationMessageInfo, CancellationToken ct = default)
 		{
 			var queryString = string.Format("/SendFnsRegistrationMessage?boxId={0}", boxId);
 			var request = BuildHttpRequest(authToken, "POST", queryString, Serialize(fnsRegistrationMessageInfo));
-			return HttpClient.PerformHttpRequestAsync(request);
+			return HttpClient.PerformHttpRequestAsync(request, ct: ct);
 		}
 
-		public Task<RevocationRequestInfo> ParseRevocationRequestXmlAsync(byte[] xmlContent)
+		public Task<RevocationRequestInfo> ParseRevocationRequestXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<RevocationRequestInfo>(null, "POST", "/ParseRevocationRequestXml", xmlContent);
+			return PerformHttpRequestAsync<RevocationRequestInfo>(null, "POST", "/ParseRevocationRequestXml", xmlContent, ct: ct);
 		}
 
-		public Task<SignatureRejectionInfo> ParseSignatureRejectionXmlAsync(byte[] xmlContent)
+		public Task<SignatureRejectionInfo> ParseSignatureRejectionXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<SignatureRejectionInfo>(null, "POST", "/ParseSignatureRejectionXml", xmlContent);
+			return PerformHttpRequestAsync<SignatureRejectionInfo>(null, "POST", "/ParseSignatureRejectionXml", xmlContent, ct: ct);
 		}
 
 		[Obsolete("Use overload with DocumentTitleType parameter")]
-		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection)
+		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection, CancellationToken ct = default)
 		{
 			var documentTitleType = CreateUtdDocumentTitleType(forBuyer, forCorrection);
-			return GetExtendedSignerDetailsAsync(token, boxId, thumbprint, documentTitleType);
+			return GetExtendedSignerDetailsAsync(token, boxId, thumbprint, documentTitleType, ct: ct);
 		}
 
 		[Obsolete("Use overload with DocumentTitleType parameter")]
-		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection)
+		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection, CancellationToken ct = default)
 		{
 			var certificate = new X509Certificate2(certificateBytes);
-			return GetExtendedSignerDetailsAsync(token, boxId, certificate.Thumbprint, forBuyer, forCorrection);
+			return GetExtendedSignerDetailsAsync(token, boxId, certificate.Thumbprint, forBuyer, forCorrection, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType)
+		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/V2/ExtendedSignerDetails");
 			queryBuilder.AddParameter("boxId", boxId);
 			queryBuilder.AddParameter("thumbprint", thumbprint);
 			queryBuilder.AddParameter("documentTitleType", ((int) documentTitleType).ToString());
-			return PerformHttpRequestAsync<ExtendedSignerDetails>(token, "GET", queryBuilder.ToString());
+			return PerformHttpRequestAsync<ExtendedSignerDetails>(token, "GET", queryBuilder.ToString(), ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType)
+		public Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType, CancellationToken ct = default)
 		{
 			var certificate = new X509Certificate2(certificateBytes);
-			return GetExtendedSignerDetailsAsync(token, boxId, certificate.Thumbprint, documentTitleType);
+			return GetExtendedSignerDetailsAsync(token, boxId, certificate.Thumbprint, documentTitleType, ct: ct);
 		}
 
 		[Obsolete("Use overload with DocumentTitleType parameter")]
-		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails)
+		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default)
 		{
 			var documentTitleType = CreateUtdDocumentTitleType(forBuyer, forCorrection);
-			return PostExtendedSignerDetailsAsync(token, boxId, thumbprint, documentTitleType, signerDetails);
+			return PostExtendedSignerDetailsAsync(token, boxId, thumbprint, documentTitleType, signerDetails, ct: ct);
 		}
 
 		[Obsolete("Use overload with DocumentTitleType parameter")]
-		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails)
+		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default)
 		{
 			var certificate = new X509Certificate2(certificateBytes);
-			return PostExtendedSignerDetailsAsync(token, boxId, certificate.Thumbprint, forBuyer, forCorrection, signerDetails);
+			return PostExtendedSignerDetailsAsync(token, boxId, certificate.Thumbprint, forBuyer, forCorrection, signerDetails, ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails)
+		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/V2/ExtendedSignerDetails");
 			queryBuilder.AddParameter("boxId", boxId);
 			queryBuilder.AddParameter("thumbprint", thumbprint);
 			queryBuilder.AddParameter("documentTitleType", ((int) documentTitleType).ToString());
-			return PerformHttpRequestAsync<ExtendedSignerDetails>(token, "POST", queryBuilder.ToString(), Serialize(signerDetails));
+			return PerformHttpRequestAsync<ExtendedSignerDetails>(token, "POST", queryBuilder.ToString(), Serialize(signerDetails), ct: ct);
 		}
 
-		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails)
+		public Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default)
 		{
 			var certificate = new X509Certificate2(certificateBytes);
-			return PostExtendedSignerDetailsAsync(token, boxId, certificate.Thumbprint, documentTitleType, signerDetails);
+			return PostExtendedSignerDetailsAsync(token, boxId, certificate.Thumbprint, documentTitleType, signerDetails, ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.KeyValueStorageAsync.cs b/src/DiadocHttpApi.KeyValueStorageAsync.cs
index 370ec980..08e0dfe0 100644
--- a/src/DiadocHttpApi.KeyValueStorageAsync.cs
+++ b/src/DiadocHttpApi.KeyValueStorageAsync.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.KeyValueStorage;
@@ -12,7 +13,8 @@ public partial class DiadocHttpApi
 		public async Task<List<KeyValueStorageEntry>> GetOrganizationStorageEntriesAsync(
 			[NotNull] string authToken,
 			[NotNull] string boxId,
-			[NotNull] IEnumerable<string> keys)
+			[NotNull] IEnumerable<string> keys, 
+			CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V2/KeyValueStorageGet");
 			qsb.AddParameter("boxId", boxId);
@@ -24,7 +26,8 @@ public async Task<List<KeyValueStorageEntry>> GetOrganizationStorageEntriesAsync
 			var response = await PerformHttpRequestAsync<KeyValueStorageApiGetRequest, KeyValueStorageApiGetResponse>(
 					authToken,
 					queryString,
-					request)
+					request,
+					ct: ct)
 				.ConfigureAwait(false);
 			return response.Entries;
 		}
@@ -32,7 +35,8 @@ public async Task<List<KeyValueStorageEntry>> GetOrganizationStorageEntriesAsync
 		public Task PutOrganizationStorageEntriesAsync(
 			[NotNull] string authToken,
 			[NotNull] string boxId,
-			[NotNull] IEnumerable<KeyValueStorageEntry> entries)
+			[NotNull] IEnumerable<KeyValueStorageEntry> entries, 
+			CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/V2/KeyValueStoragePut");
 			qsb.AddParameter("boxId", boxId);
@@ -41,7 +45,7 @@ public Task PutOrganizationStorageEntriesAsync(
 			var request = new KeyValueStorageApiPutRequest();
 			request.Entries.AddRange(entries);
 
-			return PerformHttpRequestAsync(authToken, "POST", queryString, Serialize(request));
+			return PerformHttpRequestAsync(authToken, "POST", queryString, Serialize(request), ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.Organizations.Async.cs b/src/DiadocHttpApi.Organizations.Async.cs
index f3727e4c..06cbef2c 100644
--- a/src/DiadocHttpApi.Organizations.Async.cs
+++ b/src/DiadocHttpApi.Organizations.Async.cs
@@ -1,3 +1,4 @@
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Organizations;
@@ -6,11 +7,11 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<OrganizationFeatures> GetOrganizationFeaturesAsync(string authToken, string boxId)
+		public Task<OrganizationFeatures> GetOrganizationFeaturesAsync(string authToken, string boxId, CancellationToken ct = default)
 		{
 			var queryString = new PathAndQueryBuilder("/GetOrganizationFeatures");
 			queryString.AddParameter("boxId", boxId);
-			return PerformHttpRequestAsync<OrganizationFeatures>(authToken, "GET", queryString.BuildPathAndQuery());
+			return PerformHttpRequestAsync<OrganizationFeatures>(authToken, "GET", queryString.BuildPathAndQuery(), ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.ParseAsync.cs b/src/DiadocHttpApi.ParseAsync.cs
index ee6248ed..18ffa519 100644
--- a/src/DiadocHttpApi.ParseAsync.cs
+++ b/src/DiadocHttpApi.ParseAsync.cs
@@ -1,3 +1,4 @@
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Invoicing;
@@ -6,73 +7,73 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<InvoiceInfo> ParseInvoiceXmlAsync(byte[] invoiceXmlContent)
+		public Task<InvoiceInfo> ParseInvoiceXmlAsync(byte[] invoiceXmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<InvoiceInfo>(null, "POST", "/ParseInvoiceXml", invoiceXmlContent);
+			return PerformHttpRequestAsync<InvoiceInfo>(null, "POST", "/ParseInvoiceXml", invoiceXmlContent, ct: ct);
 		}
 
-		public Task<Torg12SellerTitleInfo> ParseTorg12SellerTitleXmlAsync(byte[] xmlContent)
+		public Task<Torg12SellerTitleInfo> ParseTorg12SellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<Torg12SellerTitleInfo>(null, "POST", "/ParseTorg12SellerTitleXml", xmlContent);
+			return PerformHttpRequestAsync<Torg12SellerTitleInfo>(null, "POST", "/ParseTorg12SellerTitleXml", xmlContent, ct: ct);
 		}
 
-		public Task<Torg12BuyerTitleInfo> ParseTorg12BuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<Torg12BuyerTitleInfo> ParseTorg12BuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<Torg12BuyerTitleInfo>(null, "POST", "/ParseTorg12BuyerTitleXml", xmlContent);
+			return PerformHttpRequestAsync<Torg12BuyerTitleInfo>(null, "POST", "/ParseTorg12BuyerTitleXml", xmlContent, ct: ct);
 		}
 
-		public Task<TovTorgSellerTitleInfo> ParseTovTorg551SellerTitleXmlAsync(byte[] xmlContent)
+		public Task<TovTorgSellerTitleInfo> ParseTovTorg551SellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<TovTorgSellerTitleInfo>(null, "POST", $"/ParseTorg12SellerTitleXml?documentVersion={DefaultDocumentVersions.TovTorg551}", xmlContent);
+			return PerformHttpRequestAsync<TovTorgSellerTitleInfo>(null, "POST", $"/ParseTorg12SellerTitleXml?documentVersion={DefaultDocumentVersions.TovTorg551}", xmlContent, ct: ct);
 		}
 
-		public Task<TovTorgBuyerTitleInfo> ParseTovTorg551BuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<TovTorgBuyerTitleInfo> ParseTovTorg551BuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<TovTorgBuyerTitleInfo>(null, "POST", $"/ParseTorg12BuyerTitleXml?documentVersion={DefaultDocumentVersions.TovTorg551}", xmlContent);
+			return PerformHttpRequestAsync<TovTorgBuyerTitleInfo>(null, "POST", $"/ParseTorg12BuyerTitleXml?documentVersion={DefaultDocumentVersions.TovTorg551}", xmlContent, ct: ct);
 		}
 
-		public Task<AcceptanceCertificateSellerTitleInfo> ParseAcceptanceCertificateSellerTitleXmlAsync(byte[] xmlContent)
+		public Task<AcceptanceCertificateSellerTitleInfo> ParseAcceptanceCertificateSellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<AcceptanceCertificateSellerTitleInfo>(null, "POST", "/ParseAcceptanceCertificateSellerTitleXml", xmlContent);
+			return PerformHttpRequestAsync<AcceptanceCertificateSellerTitleInfo>(null, "POST", "/ParseAcceptanceCertificateSellerTitleXml", xmlContent, ct: ct);
 		}
 
-		public Task<AcceptanceCertificateBuyerTitleInfo> ParseAcceptanceCertificateBuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<AcceptanceCertificateBuyerTitleInfo> ParseAcceptanceCertificateBuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<AcceptanceCertificateBuyerTitleInfo>(null, "POST", "/ParseAcceptanceCertificateBuyerTitleXml", xmlContent);
+			return PerformHttpRequestAsync<AcceptanceCertificateBuyerTitleInfo>(null, "POST", "/ParseAcceptanceCertificateBuyerTitleXml", xmlContent, ct: ct);
 		}
 
-		public Task<AcceptanceCertificate552SellerTitleInfo> ParseAcceptanceCertificate552SellerTitleXmlAsync(byte[] xmlContent)
+		public Task<AcceptanceCertificate552SellerTitleInfo> ParseAcceptanceCertificate552SellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<AcceptanceCertificate552SellerTitleInfo>(null, "POST", $"/ParseAcceptanceCertificateSellerTitleXml?documentVersion={DefaultDocumentVersions.AcceptanceCerttificate552}", xmlContent);
+			return PerformHttpRequestAsync<AcceptanceCertificate552SellerTitleInfo>(null, "POST", $"/ParseAcceptanceCertificateSellerTitleXml?documentVersion={DefaultDocumentVersions.AcceptanceCerttificate552}", xmlContent, ct: ct);
 		}
 
-		public Task<AcceptanceCertificate552BuyerTitleInfo> ParseAcceptanceCertificate552BuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<AcceptanceCertificate552BuyerTitleInfo> ParseAcceptanceCertificate552BuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<AcceptanceCertificate552BuyerTitleInfo>(null, "POST", $"/ParseAcceptanceCertificateBuyerTitleXml?documentVersion={DefaultDocumentVersions.AcceptanceCerttificate552}", xmlContent);
+			return PerformHttpRequestAsync<AcceptanceCertificate552BuyerTitleInfo>(null, "POST", $"/ParseAcceptanceCertificateBuyerTitleXml?documentVersion={DefaultDocumentVersions.AcceptanceCerttificate552}", xmlContent, ct: ct);
 		}
 
-		public Task<UniversalTransferDocumentSellerTitleInfo> ParseUniversalTransferDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Utd)
+		public Task<UniversalTransferDocumentSellerTitleInfo> ParseUniversalTransferDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Utd, CancellationToken ct = default)
 		{
 			var query = new PathAndQueryBuilder("/ParseUniversalTransferDocumentSellerTitleXml");
 			query.AddParameter("documentVersion", documentVersion);
-			return PerformHttpRequestAsync<UniversalTransferDocumentSellerTitleInfo>(null, "POST", query.BuildPathAndQuery(), xmlContent);
+			return PerformHttpRequestAsync<UniversalTransferDocumentSellerTitleInfo>(null, "POST", query.BuildPathAndQuery(), xmlContent, ct: ct);
 		}
 
-		public Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalTransferDocumentBuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalTransferDocumentBuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<UniversalTransferDocumentBuyerTitleInfo>(null, "POST", "/ParseUniversalTransferDocumentBuyerTitleXml", xmlContent);
+			return PerformHttpRequestAsync<UniversalTransferDocumentBuyerTitleInfo>(null, "POST", "/ParseUniversalTransferDocumentBuyerTitleXml", xmlContent, ct: ct);
 		}
 
-		public Task<UniversalCorrectionDocumentSellerTitleInfo> ParseUniversalCorrectionDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Ucd)
+		public Task<UniversalCorrectionDocumentSellerTitleInfo> ParseUniversalCorrectionDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Ucd, CancellationToken ct = default)
 		{
 			var query = new PathAndQueryBuilder("/ParseUniversalCorrectionDocumentSellerTitleXml");
 			query.AddParameter("documentVersion", documentVersion);
-			return PerformHttpRequestAsync<UniversalCorrectionDocumentSellerTitleInfo>(null, "POST", query.BuildPathAndQuery(), xmlContent);
+			return PerformHttpRequestAsync<UniversalCorrectionDocumentSellerTitleInfo>(null, "POST", query.BuildPathAndQuery(), xmlContent, ct: ct);
 		}
 
-		public Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalCorrectionDocumentBuyerTitleXmlAsync(byte[] xmlContent)
+		public Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalCorrectionDocumentBuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<UniversalTransferDocumentBuyerTitleInfo>(null, "POST", "/ParseUniversalCorrectionDocumentBuyerTitleXml", xmlContent);
+			return PerformHttpRequestAsync<UniversalTransferDocumentBuyerTitleInfo>(null, "POST", "/ParseUniversalCorrectionDocumentBuyerTitleXml", xmlContent, ct: ct);
 		}
 
 		public Task<byte[]> ParseTitleXmlAsync(
@@ -82,7 +83,8 @@ public Task<byte[]> ParseTitleXmlAsync(
 			string documentFunction,
 			string documentVersion,
 			int titleIndex,
-			byte[] content)
+			byte[] content, 
+			CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/ParseTitleXml");
 			queryBuilder.AddParameter("boxId", boxId);
@@ -91,7 +93,7 @@ public Task<byte[]> ParseTitleXmlAsync(
 			queryBuilder.AddParameter("documentVersion", documentVersion);
 			queryBuilder.AddParameter("titleIndex", titleIndex.ToString());
 
-			return PerformHttpRequestAsync(authToken, "POST", queryBuilder.BuildPathAndQuery(), content);
+			return PerformHttpRequestAsync(authToken, "POST", queryBuilder.BuildPathAndQuery(), content, ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.PrintAsync.cs b/src/DiadocHttpApi.PrintAsync.cs
index 7baa8005..0e3e221b 100644
--- a/src/DiadocHttpApi.PrintAsync.cs
+++ b/src/DiadocHttpApi.PrintAsync.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Documents;
@@ -11,69 +12,69 @@ namespace Diadoc.Api
 	public partial class DiadocHttpApi
 	{
 		[ItemNotNull]
-		public async Task<string> GeneratePrintFormFromAttachmentAsync(string authToken, DocumentType documentType, byte[] content, string fromBoxId = null)
+		public async Task<string> GeneratePrintFormFromAttachmentAsync(string authToken, DocumentType documentType, byte[] content, string fromBoxId = null, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GeneratePrintFormFromAttachment")
 				.With("documentType", documentType.ToString());
 			if (!string.IsNullOrEmpty(fromBoxId))
 				qsb.AddParameter("fromBoxId", fromBoxId);
-			var responseBytes = await PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery(), content).ConfigureAwait(false);
+			var responseBytes = await PerformHttpRequestAsync(authToken, "POST", qsb.BuildPathAndQuery(), content, ct: ct).ConfigureAwait(false);
 			return Encoding.UTF8.GetString(responseBytes);
 		}
 
 		[ItemNotNull]
-		public Task<PrintFormResult> GeneratePrintFormAsync(string authToken, string boxId, string messageId, string documentId)
+		public Task<PrintFormResult> GeneratePrintFormAsync(string authToken, string boxId, string messageId, string documentId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GeneratePrintForm")
 				.With("boxId", boxId)
 				.With("messageId", messageId)
 				.With("documentId", documentId);
-			return GetPrintFormResultAsync(authToken, qsb.BuildPathAndQuery());
+			return GetPrintFormResultAsync(authToken, qsb.BuildPathAndQuery(), ct: ct);
 		}
 
 		[ItemNotNull]
 		[Obsolete("Use GetGeneratedPrintFormAsync without `documentType` parameter")]
-		public Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, DocumentType documentType, string printFormId)
+		public Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, DocumentType documentType, string printFormId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetGeneratedPrintForm")
 				.With("documentType", documentType.ToString())
 				.With("printFormId", printFormId);
-			return GetPrintFormResultAsync(authToken, qsb.BuildPathAndQuery());
+			return GetPrintFormResultAsync(authToken, qsb.BuildPathAndQuery(), ct: ct);
 		}
 
 		[ItemNotNull]
-		public Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, string printFormId)
+		public Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, string printFormId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetGeneratedPrintForm")
 				.With("printFormId", printFormId);
-			return GetPrintFormResultAsync(authToken, qsb.BuildPathAndQuery());
+			return GetPrintFormResultAsync(authToken, qsb.BuildPathAndQuery(), ct: ct);
 		}
 
 		[ItemNotNull]
-		protected async Task<PrintFormResult> GetPrintFormResultAsync([CanBeNull] string authToken, [NotNull] string queryString)
+		protected async Task<PrintFormResult> GetPrintFormResultAsync([CanBeNull] string authToken, [NotNull] string queryString, CancellationToken ct = default)
 		{
 			var request = BuildHttpRequest(authToken, "GET", queryString, null);
-			var response = await HttpClient.PerformHttpRequestAsync(request).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct).ConfigureAwait(false);
 			return response.RetryAfter.HasValue
 				? new PrintFormResult(response.RetryAfter.Value)
 				: new PrintFormResult(new PrintFormContent(response.ContentType, response.ContentDispositionFileName, response.Content));
 		}
 
 		[ItemNotNull]
-		public Task<DocumentProtocolResult> GenerateDocumentProtocolAsync(string authToken, string boxId, string messageId, string documentId)
+		public Task<DocumentProtocolResult> GenerateDocumentProtocolAsync(string authToken, string boxId, string messageId, string documentId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GenerateDocumentProtocol")
 				.With("boxId", boxId)
 				.With("messageId", messageId)
 				.With("documentId", documentId);
 			var request = BuildHttpRequest(authToken, "GET", qsb.BuildPathAndQuery(), null);
-			return GenerateDocumentProtocolAsync(request);
+			return GenerateDocumentProtocolAsync(request, ct: ct);
 		}
 
 		[ItemNotNull]
-		protected async Task<DocumentProtocolResult> GenerateDocumentProtocolAsync([NotNull] HttpRequest request)
+		protected async Task<DocumentProtocolResult> GenerateDocumentProtocolAsync([NotNull] HttpRequest request, CancellationToken ct = default)
 		{
-			var response = await HttpClient.PerformHttpRequestAsync(request).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct).ConfigureAwait(false);
 			return response.RetryAfter.HasValue
 				? new DocumentProtocolResult(response.RetryAfter.Value)
 				: new DocumentProtocolResult(Deserialize<DocumentProtocol>(response.Content));
diff --git a/src/DiadocHttpApi.ReceiptsAsync.cs b/src/DiadocHttpApi.ReceiptsAsync.cs
index 6d52a178..d2bfbf7b 100644
--- a/src/DiadocHttpApi.ReceiptsAsync.cs
+++ b/src/DiadocHttpApi.ReceiptsAsync.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Proto.Events;
 using Diadoc.Api.Proto.Invoicing;
@@ -8,16 +9,16 @@ namespace Diadoc.Api
 	public partial class DiadocHttpApi
 	{
 		[Obsolete("Use GenerateReceiptXmlAsync()")]
-		public Task<GeneratedFile> GenerateDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer)
+		public Task<GeneratedFile> GenerateDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer, CancellationToken ct = default)
 		{
 			var queryString = $"/GenerateDocumentReceiptXml?boxId={boxId}&messageId={messageId}&attachmentId={attachmentId}";
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, signer);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, signer, ct: ct);
 		}
 
-		public Task<GeneratedFile> GenerateReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer)
+		public Task<GeneratedFile> GenerateReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer, CancellationToken ct = default)
 		{
 			var queryString = $"/GenerateReceiptXml?boxId={boxId}&messageId={messageId}&attachmentId={attachmentId}";
-			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, signer);
+			return PerformGenerateXmlHttpRequestAsync(authToken, queryString, signer, ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.RecognizeAsync.cs b/src/DiadocHttpApi.RecognizeAsync.cs
index 548df2c4..a55df5df 100644
--- a/src/DiadocHttpApi.RecognizeAsync.cs
+++ b/src/DiadocHttpApi.RecognizeAsync.cs
@@ -1,4 +1,5 @@
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Proto;
 using Diadoc.Api.Proto.Recognition;
@@ -7,23 +8,23 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public async Task<string> RecognizeAsync(string fileName, byte[] content)
+		public async Task<string> RecognizeAsync(string fileName, byte[] content, CancellationToken ct = default)
 		{
 			var queryString = $"/Recognize?filename={fileName}";
-			var responseBytes = await PerformHttpRequestAsync(null, "POST", queryString, content).ConfigureAwait(false);
+			var responseBytes = await PerformHttpRequestAsync(null, "POST", queryString, content, ct: ct).ConfigureAwait(false);
 			return Encoding.UTF8.GetString(responseBytes);
 		}
 
-		public Task<Recognized> GetRecognizedAsync(string recognitionId)
+		public Task<Recognized> GetRecognizedAsync(string recognitionId, CancellationToken ct = default)
 		{
 			var queryString = $"/GetRecognized?recognitionId={recognitionId}";
-			return PerformHttpRequestAsync<Recognized>(null, "GET", queryString);
+			return PerformHttpRequestAsync<Recognized>(null, "GET", queryString, ct: ct);
 		}
 
-		public Task<RussianAddress> ParseRussianAddressAsync(string address)
+		public Task<RussianAddress> ParseRussianAddressAsync(string address, CancellationToken ct = default)
 		{
 			var queryString = $"/ParseRussianAddress?address={address}";
-			return PerformHttpRequestAsync<RussianAddress>(null, "GET", queryString);
+			return PerformHttpRequestAsync<RussianAddress>(null, "GET", queryString, ct: ct);
 		}
 	}
 }
diff --git a/src/DiadocHttpApi.ReferencesAsync.cs b/src/DiadocHttpApi.ReferencesAsync.cs
index bc9b45b5..c60c8061 100644
--- a/src/DiadocHttpApi.ReferencesAsync.cs
+++ b/src/DiadocHttpApi.ReferencesAsync.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto;
@@ -9,119 +10,119 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<OrganizationUserPermissions> GetMyPermissionsAsync(string authToken, string orgId)
+		public Task<OrganizationUserPermissions> GetMyPermissionsAsync(string authToken, string orgId, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetMyPermissions");
 			qsb.AddParameter("orgId", orgId);
-			return PerformHttpRequestAsync<OrganizationUserPermissions>(authToken, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<OrganizationUserPermissions>(authToken, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<OrganizationList> GetMyOrganizationsAsync(string authToken, bool autoRegister = true)
+		public Task<OrganizationList> GetMyOrganizationsAsync(string authToken, bool autoRegister = true, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GetMyOrganizations");
 			if (!autoRegister) queryBuilder.AddParameter("autoRegister", "false");
-			return PerformHttpRequestAsync<OrganizationList>(authToken, "GET", queryBuilder.BuildPathAndQuery());
+			return PerformHttpRequestAsync<OrganizationList>(authToken, "GET", queryBuilder.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<User> GetMyUserAsync(string authToken)
+		public Task<User> GetMyUserAsync(string authToken, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<User>(authToken, "GET", "/GetMyUser");
+			return PerformHttpRequestAsync<User>(authToken, "GET", "/GetMyUser", ct: ct);
 		}
 
-		public Task<UserV2> GetMyUserV2Async(string authToken)
+		public Task<UserV2> GetMyUserV2Async(string authToken, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<UserV2>(authToken, "GET", "/V2/GetMyUser");
+			return PerformHttpRequestAsync<UserV2>(authToken, "GET", "/V2/GetMyUser", ct: ct);
 		}
 
-		public Task<UserV2> UpdateMyUserAsync(string authToken, UserToUpdate userToUpdate)
+		public Task<UserV2> UpdateMyUserAsync(string authToken, UserToUpdate userToUpdate, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<UserToUpdate, UserV2>(authToken, "/UpdateMyUser", userToUpdate);
+			return PerformHttpRequestAsync<UserToUpdate, UserV2>(authToken, "/UpdateMyUser", userToUpdate, ct: ct);
 		}
 		
-		public Task<CertificateList> GetMyCertificatesAsync(string authToken, string boxId)
+		public Task<CertificateList> GetMyCertificatesAsync(string authToken, string boxId, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GetMyCertificates");
 			queryBuilder.AddParameter("boxId", boxId);
 
-			return PerformHttpRequestAsync<CertificateList>(authToken, "GET", queryBuilder.BuildPathAndQuery());
+			return PerformHttpRequestAsync<CertificateList>(authToken, "GET", queryBuilder.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<OrganizationList> GetOrganizationsByInnKppAsync(string inn, string kpp, bool includeRelations = false)
+		public Task<OrganizationList> GetOrganizationsByInnKppAsync(string inn, string kpp, bool includeRelations = false, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetOrganizationsByInnKpp");
 			qsb.AddParameter("inn", inn);
 			if (!string.IsNullOrEmpty(kpp)) qsb.AddParameter("kpp", kpp);
 			if (includeRelations)
 				qsb.AddParameter("includeRelations", "true");
-			return PerformHttpRequestAsync<OrganizationList>(null, "GET", qsb.BuildPathAndQuery());
+			return PerformHttpRequestAsync<OrganizationList>(null, "GET", qsb.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task<Organization> GetOrganizationByIdAsync(string orgId)
+		public Task<Organization> GetOrganizationByIdAsync(string orgId, CancellationToken ct = default)
 		{
-			return GetOrganizationAsync($"/GetOrganization?orgId={orgId}");
+			return GetOrganizationAsync($"/GetOrganization?orgId={orgId}", ct: ct);
 		}
 
-		public Task<Organization> GetOrganizationByBoxIdAsync(string boxId)
+		public Task<Organization> GetOrganizationByBoxIdAsync(string boxId, CancellationToken ct = default)
 		{
-			return GetOrganizationAsync($"/GetOrganization?boxId={boxId}");
+			return GetOrganizationAsync($"/GetOrganization?boxId={boxId}", ct: ct);
 		}
 
-		public Task<Organization> GetOrganizationByFnsParticipantIdAsync(string fnsParticipantId)
+		public Task<Organization> GetOrganizationByFnsParticipantIdAsync(string fnsParticipantId, CancellationToken ct = default)
 		{
-			return GetOrganizationAsync($"/GetOrganization?fnsParticipantId={fnsParticipantId}");
+			return GetOrganizationAsync($"/GetOrganization?fnsParticipantId={fnsParticipantId}", ct: ct);
 		}
 
-		public Task<Organization> GetOrganizationByInnKppAsync(string inn, string kpp)
+		public Task<Organization> GetOrganizationByInnKppAsync(string inn, string kpp, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GetOrganization");
 			qsb.AddParameter("inn", inn);
 			if (!string.IsNullOrEmpty(kpp))
 				qsb.AddParameter("kpp", kpp);
 			var queryString = qsb.BuildPathAndQuery();
-			return GetOrganizationAsync(queryString);
+			return GetOrganizationAsync(queryString, ct: ct);
 		}
 
-		private Task<Organization> GetOrganizationAsync(string queryString)
+		private Task<Organization> GetOrganizationAsync(string queryString, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync<Organization>(null, "GET", queryString);
+			return PerformHttpRequestAsync<Organization>(null, "GET", queryString, ct: ct);
 		}
 
-		public Task<Box> GetBoxAsync(string boxId)
+		public Task<Box> GetBoxAsync(string boxId, CancellationToken ct = default)
 		{
 			var queryString = $"/GetBox?boxId={boxId}";
-			return PerformHttpRequestAsync<Box>(null, "GET", queryString);
+			return PerformHttpRequestAsync<Box>(null, "GET", queryString, ct: ct);
 		}
 
-		public Task<Department> GetDepartmentAsync(string authToken, string orgId, string departmentId)
+		public Task<Department> GetDepartmentAsync(string authToken, string orgId, string departmentId, CancellationToken ct = default)
 		{
 			var queryBuilder = new PathAndQueryBuilder("/GetDepartment");
 			queryBuilder.AddParameter("orgId", orgId);
 			queryBuilder.AddParameter("departmentId", departmentId);
-			return PerformHttpRequestAsync<Department>(authToken, "GET", queryBuilder.BuildPathAndQuery());
+			return PerformHttpRequestAsync<Department>(authToken, "GET", queryBuilder.BuildPathAndQuery(), ct: ct);
 		}
 
-		public Task UpdateOrganizationPropertiesAsync(string authToken, OrganizationPropertiesToUpdate orgProps)
+		public Task UpdateOrganizationPropertiesAsync(string authToken, OrganizationPropertiesToUpdate orgProps, CancellationToken ct = default)
 		{
-			return PerformHttpRequestAsync(authToken, "POST", "/UpdateOrganizationProperties", Serialize(orgProps));
+			return PerformHttpRequestAsync(authToken, "POST", "/UpdateOrganizationProperties", Serialize(orgProps), ct: ct);
 		}
 
-		public Task<OrganizationUsersList> GetOrganizationUsersAsync(string authToken, string orgId)
+		public Task<OrganizationUsersList> GetOrganizationUsersAsync(string authToken, string orgId, CancellationToken ct = default)
 		{
 			var queryString = $"/GetOrganizationUsers?orgId={orgId}";
-			return PerformHttpRequestAsync<OrganizationUsersList>(authToken, "GET", queryString);
+			return PerformHttpRequestAsync<OrganizationUsersList>(authToken, "GET", queryString, ct: ct);
 		}
 
-		public async Task<List<Organization>> GetOrganizationsByInnListAsync(GetOrganizationsByInnListRequest innList)
+		public async Task<List<Organization>> GetOrganizationsByInnListAsync(GetOrganizationsByInnListRequest innList, CancellationToken ct = default)
 		{
 			const string queryString = "/GetOrganizationsByInnList";
-			var response = await PerformHttpRequestAsync<GetOrganizationsByInnListRequest, GetOrganizationsByInnListResponse>(null, queryString, innList).ConfigureAwait(false);
+			var response = await PerformHttpRequestAsync<GetOrganizationsByInnListRequest, GetOrganizationsByInnListResponse>(null, queryString, innList, ct: ct).ConfigureAwait(false);
 			return response.Organizations.Select(o => o.Organization).ToList();
 		}
 
-		public async Task<List<OrganizationWithCounteragentStatus>> GetOrganizationsByInnListAsync(string authToken, string myOrgId, GetOrganizationsByInnListRequest innList)
+		public async Task<List<OrganizationWithCounteragentStatus>> GetOrganizationsByInnListAsync(string authToken, string myOrgId, GetOrganizationsByInnListRequest innList, CancellationToken ct = default)
 		{
 			var queryString = $"/GetOrganizationsByInnList?myOrgId={myOrgId}";
-			var response = await PerformHttpRequestAsync<GetOrganizationsByInnListRequest, GetOrganizationsByInnListResponse>(authToken, queryString, innList).ConfigureAwait(false);
+			var response = await PerformHttpRequestAsync<GetOrganizationsByInnListRequest, GetOrganizationsByInnListResponse>(authToken, queryString, innList, ct: ct).ConfigureAwait(false);
 			return response.Organizations;
 		}
 	}
diff --git a/src/DiadocHttpApi.RegistrationAsync.cs b/src/DiadocHttpApi.RegistrationAsync.cs
index f2061918..f33e94a8 100644
--- a/src/DiadocHttpApi.RegistrationAsync.cs
+++ b/src/DiadocHttpApi.RegistrationAsync.cs
@@ -1,25 +1,28 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Diadoc.Api.Proto.Registration;
 
 namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public Task<RegistrationResponse> RegisterAsync(string authToken, RegistrationRequest registrationRequest)
+		public Task<RegistrationResponse> RegisterAsync(string authToken, RegistrationRequest registrationRequest, CancellationToken ct = default)
 		{
 			return PerformHttpRequestAsync<RegistrationRequest, RegistrationResponse>(
 				authToken,
 				"/Register",
-				registrationRequest);
+				registrationRequest,
+				ct: ct);
 		}
 
-		public Task RegisterConfirmAsync(string authToken, RegistrationConfirmRequest registrationConfirmRequest)
+		public Task RegisterConfirmAsync(string authToken, RegistrationConfirmRequest registrationConfirmRequest, CancellationToken ct = default)
 		{
 			return PerformHttpRequestAsync(
 				authToken,
 				"POST",
 				"/RegisterConfirm",
-				Serialize(registrationConfirmRequest));
+				Serialize(registrationConfirmRequest),
+				ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.ShelfAsync.cs b/src/DiadocHttpApi.ShelfAsync.cs
index 20c9dc59..c341949f 100644
--- a/src/DiadocHttpApi.ShelfAsync.cs
+++ b/src/DiadocHttpApi.ShelfAsync.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using JetBrains.Annotations;
@@ -10,7 +11,7 @@ namespace Diadoc.Api
 {
 	public partial class DiadocHttpApi
 	{
-		public async Task<string> UploadFileToShelfAsync(string authToken, byte[] data)
+		public async Task<string> UploadFileToShelfAsync(string authToken, byte[] data, CancellationToken ct = default)
 		{
 			var nameOnShelf = $"api-{Guid.NewGuid()}";
 			var parts = SplitDataIntoParts(data).ToList();
@@ -22,36 +23,36 @@ public async Task<string> UploadFileToShelfAsync(string authToken, byte[] data)
 			{
 				if (++attempts > maxAttempts)
 					throw new AggregateException("Reached the limit of attempts to send a file", httpErrors.ToArray());
-				missingParts = await PutMissingPartsAsync(authToken, nameOnShelf, parts, missingParts, httpErrors).ConfigureAwait(false);
+				missingParts = await PutMissingPartsAsync(authToken, nameOnShelf, parts, missingParts, httpErrors, ct: ct).ConfigureAwait(false);
 			}
 
 			return nameOnShelf;
 		}
 
 		[ItemNotNull]
-		private async Task<int[]> PutMissingPartsAsync(string authToken, string nameOnShelf, [NotNull] IList<ArraySegment<byte>> allParts, [NotNull] IList<int> missingParts, [NotNull] ICollection<HttpClientException> httpErrors)
+		private async Task<int[]> PutMissingPartsAsync(string authToken, string nameOnShelf, [NotNull] IList<ArraySegment<byte>> allParts, [NotNull] IList<int> missingParts, [NotNull] ICollection<HttpClientException> httpErrors, CancellationToken ct = default)
 		{
 			int[] currentMissingParts = null;
 			for (var i = 0; i < missingParts.Count; ++i)
 			{
 				var partIndex = missingParts[i];
-				currentMissingParts = await PutPartAsync(authToken, nameOnShelf, allParts[partIndex], partIndex, i == missingParts.Count - 1, httpErrors).ConfigureAwait(false);
+				currentMissingParts = await PutPartAsync(authToken, nameOnShelf, allParts[partIndex], partIndex, i == missingParts.Count - 1, httpErrors, ct: ct).ConfigureAwait(false);
 			}
 			if (currentMissingParts == null)
 				throw new Exception("ShelfUpload did not return missing parts");
 			return currentMissingParts;
 		}
 
-		public Task<byte[]> GetFileFromShelfAsync(string authToken, string nameOnShelf)
+		public Task<byte[]> GetFileFromShelfAsync(string authToken, string nameOnShelf, CancellationToken ct = default)
 		{
 			if (!nameOnShelf.Contains("__userId__"))
 				nameOnShelf = $"__userId__/{nameOnShelf}";
 			var queryString = $"ShelfDownload?nameOnShelf={nameOnShelf}";
-			return PerformHttpRequestAsync(authToken, "GET", queryString);
+			return PerformHttpRequestAsync(authToken, "GET", queryString, ct: ct);
 		}
 
 		[ItemCanBeNull]
-		private async Task<int[]> PutPartAsync(string authToken, string nameOnShelf, ArraySegment<byte> part, int partIndex, bool isLast, ICollection<HttpClientException> httpErrors)
+		private async Task<int[]> PutPartAsync(string authToken, string nameOnShelf, ArraySegment<byte> part, int partIndex, bool isLast, ICollection<HttpClientException> httpErrors, CancellationToken ct = default)
 		{
 			var queryString = $"ShelfUpload?nameOnShelf=__userId__/{nameOnShelf}&partIndex={partIndex}";
 			if (isLast)
@@ -59,7 +60,7 @@ private async Task<int[]> PutPartAsync(string authToken, string nameOnShelf, Arr
 			try
 			{
 				var request = BuildRequest(authToken, "POST", queryString, new HttpRequestBody(part));
-				var response = await HttpClient.PerformHttpRequestAsync(request).ConfigureAwait(false);
+				var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct).ConfigureAwait(false);
 				if (isLast)
 				{
 					var responseString = Encoding.UTF8.GetString(response.Content);
diff --git a/src/DiadocHttpApi.UniversalTransferDocumentAsync.cs b/src/DiadocHttpApi.UniversalTransferDocumentAsync.cs
index 6b379143..a19480e3 100644
--- a/src/DiadocHttpApi.UniversalTransferDocumentAsync.cs
+++ b/src/DiadocHttpApi.UniversalTransferDocumentAsync.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Events;
 using Diadoc.Api.Proto.Invoicing;
@@ -11,19 +12,21 @@ public Task<GeneratedFile> GenerateUniversalTransferDocumentXmlForSellerAsync(
 			string authToken,
 			UniversalTransferDocumentSellerTitleInfo info,
 			bool disableValidation = false,
-			string documentVersion = null)
+			string documentVersion = null,
+			CancellationToken ct = default)
 		{
 
-			return GenerateUniversalTransferDocumentXmlAsync(authToken, info, false, disableValidation, documentVersion);
+			return GenerateUniversalTransferDocumentXmlAsync(authToken, info, false, disableValidation, documentVersion, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateUniversalCorrectionDocumentXmlForSellerAsync(
 			string authToken,
 			UniversalCorrectionDocumentSellerTitleInfo correctionInfo,
 			bool disableValidation = false,
-			string documentVersion = null)
+			string documentVersion = null,
+			CancellationToken ct = default)
 		{
-			return GenerateUniversalTransferDocumentXmlAsync(authToken, correctionInfo, true, disableValidation, documentVersion);
+			return GenerateUniversalTransferDocumentXmlAsync(authToken, correctionInfo, true, disableValidation, documentVersion, ct: ct);
 		}
 
 		private Task<GeneratedFile> GenerateUniversalTransferDocumentXmlAsync<T>(
@@ -31,7 +34,8 @@ private Task<GeneratedFile> GenerateUniversalTransferDocumentXmlAsync<T>(
 			T protoInfo, 
 			bool isCorrection, 
 			bool disableValidation = false,
-			string documentVersion = null) 
+			string documentVersion = null,
+			CancellationToken ct = default) 
 			where T : class
 		{
 			var query = new PathAndQueryBuilder("/GenerateUniversalTransferDocumentXmlForSeller");
@@ -40,17 +44,17 @@ private Task<GeneratedFile> GenerateUniversalTransferDocumentXmlAsync<T>(
 				query.AddParameter("correction", "");
 			if (disableValidation)
 				query.AddParameter("disableValidation", "");
-			return PerformGenerateXmlHttpRequestAsync(authToken, query.BuildPathAndQuery(), protoInfo);
+			return PerformGenerateXmlHttpRequestAsync(authToken, query.BuildPathAndQuery(), protoInfo, ct: ct);
 		}
 
 		public Task<GeneratedFile> GenerateUniversalTransferDocumentXmlForBuyerAsync(string authToken, UniversalTransferDocumentBuyerTitleInfo info,
-			string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId)
+			string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default)
 		{
 			var query = new PathAndQueryBuilder("/GenerateUniversalTransferDocumentXmlForBuyer");
 			query.AddParameter("boxId", boxId);
 			query.AddParameter("sellerTitleMessageId", sellerTitleMessageId);
 			query.AddParameter("sellerTitleAttachmentId", sellerTitleAttachmentId);
-			return PerformGenerateXmlHttpRequestAsync(authToken, query.BuildPathAndQuery(), info);
+			return PerformGenerateXmlHttpRequestAsync(authToken, query.BuildPathAndQuery(), info, ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/DiadocHttpApi.WaitTaskResultAsync.cs b/src/DiadocHttpApi.WaitTaskResultAsync.cs
index fa104d7a..55d26294 100644
--- a/src/DiadocHttpApi.WaitTaskResultAsync.cs
+++ b/src/DiadocHttpApi.WaitTaskResultAsync.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.Net;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace Diadoc.Api
@@ -12,7 +13,8 @@ protected async Task<TResult> WaitTaskResultAsync<TResult>(
 			string url,
 			string taskId,
 			TimeSpan? timeout = null,
-			TimeSpan? delay = null)
+			TimeSpan? delay = null,
+			CancellationToken ct = default)
 			where TResult: class
 		{
 			var queryString = $"{url}?taskId={taskId}";
@@ -21,7 +23,7 @@ protected async Task<TResult> WaitTaskResultAsync<TResult>(
 			while (true)
 			{
 				var request = BuildHttpRequest(authToken, "GET", queryString, null);
-				var response = await HttpClient.PerformHttpRequestAsync(request, HttpStatusCode.NoContent).ConfigureAwait(false);
+				var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct, HttpStatusCode.NoContent).ConfigureAwait(false);
 
 				if (response.StatusCode == HttpStatusCode.NoContent)
 				{
diff --git a/src/DiadocHttpApi.ZipAsync.cs b/src/DiadocHttpApi.ZipAsync.cs
index dd64797f..a8ab6267 100644
--- a/src/DiadocHttpApi.ZipAsync.cs
+++ b/src/DiadocHttpApi.ZipAsync.cs
@@ -1,4 +1,5 @@
-using System.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
 using Diadoc.Api.Http;
 using Diadoc.Api.Proto.Documents;
 using JetBrains.Annotations;
@@ -8,7 +9,7 @@ namespace Diadoc.Api
 	public partial class DiadocHttpApi
 	{
 		[ItemNotNull]
-		public async Task<DocumentZipGenerationResult> GenerateDocumentZipAsync(string authToken, string boxId, string messageId, string documentId, bool fullDocflow)
+		public async Task<DocumentZipGenerationResult> GenerateDocumentZipAsync(string authToken, string boxId, string messageId, string documentId, bool fullDocflow, CancellationToken ct = default)
 		{
 			var qsb = new PathAndQueryBuilder("/GenerateDocumentZip");
 			qsb.AddParameter("boxId", boxId);
@@ -16,7 +17,7 @@ public async Task<DocumentZipGenerationResult> GenerateDocumentZipAsync(string a
 			qsb.AddParameter("documentId", documentId);
 			qsb.AddParameter("fullDocflow", fullDocflow.ToString());
 			var request = BuildHttpRequest(authToken, "GET", qsb.BuildPathAndQuery(), null);
-			var response = await HttpClient.PerformHttpRequestAsync(request).ConfigureAwait(false);
+			var response = await HttpClient.PerformHttpRequestAsync(request, ct: ct).ConfigureAwait(false);
 			var result = Deserialize<DocumentZipGenerationResult>(response.Content);
 			if (response.RetryAfter.HasValue)
 				result.RetryAfter = response.RetryAfter.Value;
diff --git a/src/DocflowApi.Async.cs b/src/DocflowApi.Async.cs
index ead6bffd..239c256b 100644
--- a/src/DocflowApi.Async.cs
+++ b/src/DocflowApi.Async.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Threading;
 using System.Threading.Tasks;
 using Diadoc.Api.Proto.Docflow;
 
@@ -6,29 +7,29 @@ namespace Diadoc.Api
 {
 	public partial class DocflowApi : IDocflowApi
 	{
-		public Task<GetDocflowBatchResponseV3> GetDocflowsAsync(string authToken, string boxId, GetDocflowBatchRequest request)
+		public Task<GetDocflowBatchResponseV3> GetDocflowsAsync(string authToken, string boxId, GetDocflowBatchRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return docflowHttpApi.GetDocflowsAsync(authToken, boxId, request);
+			return docflowHttpApi.GetDocflowsAsync(authToken, boxId, request, ct: ct);
 		}
 
-		public Task<GetDocflowEventsResponseV3> GetDocflowEventsAsync(string authToken, string boxId, GetDocflowEventsRequest request)
+		public Task<GetDocflowEventsResponseV3> GetDocflowEventsAsync(string authToken, string boxId, GetDocflowEventsRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return docflowHttpApi.GetDocflowEventsAsync(authToken, boxId, request);
+			return docflowHttpApi.GetDocflowEventsAsync(authToken, boxId, request, ct: ct);
 		}
 
-		public Task<SearchDocflowsResponseV3> SearchDocflowsAsync(string authToken, string boxId, SearchDocflowsRequest request)
+		public Task<SearchDocflowsResponseV3> SearchDocflowsAsync(string authToken, string boxId, SearchDocflowsRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return docflowHttpApi.SearchDocflowsAsync(authToken, boxId, request);
+			return docflowHttpApi.SearchDocflowsAsync(authToken, boxId, request, ct: ct);
 		}
 
 		public Task<GetDocflowsByPacketIdResponseV3> GetDocflowsByPacketIdAsync(string authToken, string boxId,
-			GetDocflowsByPacketIdRequest request)
+			GetDocflowsByPacketIdRequest request, CancellationToken ct = default)
 		{
 			if (string.IsNullOrEmpty(boxId)) throw new ArgumentNullException("boxId");
-			return docflowHttpApi.GetDocflowsByPacketIdAsync(authToken, boxId, request);
+			return docflowHttpApi.GetDocflowsByPacketIdAsync(authToken, boxId, request, ct: ct);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/Http/HttpClient.cs b/src/Http/HttpClient.cs
index a4808c7d..9cbcf58b 100644
--- a/src/Http/HttpClient.cs
+++ b/src/Http/HttpClient.cs
@@ -9,6 +9,7 @@
 using JetBrains.Annotations;
 
 #if !NET35
+using System.Threading;
 using System.Threading.Tasks;
 #endif
 
@@ -28,7 +29,7 @@ public interface IHttpClient
 		#if !NET35
 
 		[ItemNotNull]
-		Task<HttpResponse> PerformHttpRequestAsync([NotNull] HttpRequest request, params HttpStatusCode[] allowedStatusCodes);
+		Task<HttpResponse> PerformHttpRequestAsync([NotNull] HttpRequest request, CancellationToken ct = default, params HttpStatusCode[] allowedStatusCodes);
 
 		#endif
 	}
@@ -136,13 +137,13 @@ public virtual HttpResponse PerformHttpRequest([NotNull] HttpRequest request, pa
 		#if !NET35
 
 		[ItemNotNull]
-		public virtual async Task<HttpResponse> PerformHttpRequestAsync(HttpRequest request, params HttpStatusCode[] allowedStatusCodes)
+		public virtual async Task<HttpResponse> PerformHttpRequestAsync(HttpRequest request, CancellationToken ct = default, params HttpStatusCode[] allowedStatusCodes)
 		{
 			HttpResponse response = null;
 			try
 			{
 				var webRequest = PrepareWebRequest(request);
-				using (var webResponse = await webRequest.GetResponseAsync().ConfigureAwait(false))
+				using (var webResponse = await webRequest.GetResponseAsync(ct).ConfigureAwait(false))
 					response = new HttpResponse((HttpWebResponse)webResponse);
 				if (!StatusCodeIsAllowed(response.StatusCode, allowedStatusCodes))
 				{
diff --git a/src/IDiadocApi.cs b/src/IDiadocApi.cs
index 435c81e1..d7dbb4d2 100644
--- a/src/IDiadocApi.cs
+++ b/src/IDiadocApi.cs
@@ -24,6 +24,7 @@
 using Employee = Diadoc.Api.Proto.Employees.Employee;
 
 #if !NET35
+using System.Threading;
 using System.Threading.Tasks;
 #endif
 
@@ -234,148 +235,150 @@ byte[] ParseTitleXml(
 
 #if !NET35
 
-		Task<string> AuthenticateAsync(string login, string password, string key = null, string id = null);
-		Task<string> AuthenticateByKeyAsync([NotNull] string key, [NotNull] string id);
-		Task<string> AuthenticateBySidAsync([NotNull] string sid);
-		Task<string> AuthenticateAsync(byte[] certificateBytes, bool useLocalSystemStorage = false);
-		Task<string> AuthenticateAsync(string thumbprint, bool useLocalSystemStorage = false);
+		Task<string> AuthenticateAsync(string login, string password, string key = null, string id = null, CancellationToken ct = default);
+		Task<string> AuthenticateByKeyAsync([NotNull] string key, [NotNull] string id, CancellationToken ct = default);
+		Task<string> AuthenticateBySidAsync([NotNull] string sid, CancellationToken ct = default);
+		Task<string> AuthenticateAsync(byte[] certificateBytes, bool useLocalSystemStorage = false, CancellationToken ct = default);
+		Task<string> AuthenticateAsync(string thumbprint, bool useLocalSystemStorage = false, CancellationToken ct = default);
 		Task<string> AuthenticateWithKeyAsync(string thumbprint, bool useLocalSystemStorage = false, string key =
- null, string id = null, bool autoConfirm = true);
+ null, string id = null, bool autoConfirm = true, CancellationToken ct = default);
 		Task<string> AuthenticateWithKeyAsync(byte[] certificateBytes, bool useLocalSystemStorage = false, string key =
- null, string id = null, bool autoConfirm = true);
-		Task<string> AuthenticateWithKeyConfirmAsync(byte[] certificateBytes, string token, bool saveBinding = false);
-		Task<string> AuthenticateWithKeyConfirmAsync(string thumbprint, string token, bool saveBinding = false);
-		Task<OrganizationUserPermissions> GetMyPermissionsAsync(string authToken, string orgId);
-		Task<OrganizationList> GetMyOrganizationsAsync(string authToken, bool autoRegister = true);
+ null, string id = null, bool autoConfirm = true, CancellationToken ct = default);
+		Task<string> AuthenticateWithKeyConfirmAsync(byte[] certificateBytes, string token, bool saveBinding = false, CancellationToken ct = default);
+		Task<string> AuthenticateWithKeyConfirmAsync(string thumbprint, string token, bool saveBinding = false, CancellationToken ct = default);
+		Task<OrganizationUserPermissions> GetMyPermissionsAsync(string authToken, string orgId, CancellationToken ct = default);
+		Task<OrganizationList> GetMyOrganizationsAsync(string authToken, bool autoRegister = true, CancellationToken ct = default);
 		[Obsolete("Use GetMyUserV2Async")]
-		Task<User> GetMyUserAsync(string authToken);
-		Task<UserV2> GetMyUserV2Async(string authToken);
-		Task<UserV2> UpdateMyUserAsync(string authToken, UserToUpdate userToUpdate);
-		Task<CertificateList> GetMyCertificatesAsync(string authToken, string boxId);
-		Task<OrganizationList> GetOrganizationsByInnKppAsync(string inn, string kpp, bool includeRelations = false);
-		Task<Organization> GetOrganizationByIdAsync(string orgId);
-		Task<Organization> GetOrganizationByBoxIdAsync(string boxId);
-		Task<Organization> GetOrganizationByFnsParticipantIdAsync(string fnsParticipantId);
-		Task<Organization> GetOrganizationByInnKppAsync(string inn, string kpp);
-		Task<Box> GetBoxAsync(string boxId);
-		Task<Department> GetDepartmentAsync(string authToken, string orgId, string departmentId);
-		Task UpdateOrganizationPropertiesAsync(string authToken, OrganizationPropertiesToUpdate orgProps);
-		Task<OrganizationFeatures> GetOrganizationFeaturesAsync(string authToken, string boxId);
-		Task<BoxEventList> GetNewEventsAsync(string authToken, string boxId, string afterEventId = null);
-		Task<BoxEvent> GetEventAsync(string authToken, string boxId, string eventId);
-		Task<Message> PostMessageAsync(string authToken, MessageToPost msg, string operationId = null);
-		Task<Template> PostTemplateAsync(string authToken, TemplateToPost template, string operationId = null);
+		Task<User> GetMyUserAsync(string authToken, CancellationToken ct = default);
+		Task<UserV2> GetMyUserV2Async(string authToken, CancellationToken ct = default);
+		Task<UserV2> UpdateMyUserAsync(string authToken, UserToUpdate userToUpdate, CancellationToken ct = default);
+		Task<CertificateList> GetMyCertificatesAsync(string authToken, string boxId, CancellationToken ct = default);
+		Task<OrganizationList> GetOrganizationsByInnKppAsync(string inn, string kpp, bool includeRelations = false, CancellationToken ct = default);
+		Task<Organization> GetOrganizationByIdAsync(string orgId, CancellationToken ct = default);
+		Task<Organization> GetOrganizationByBoxIdAsync(string boxId, CancellationToken ct = default);
+		Task<Organization> GetOrganizationByFnsParticipantIdAsync(string fnsParticipantId, CancellationToken ct = default);
+		Task<Organization> GetOrganizationByInnKppAsync(string inn, string kpp, CancellationToken ct = default);
+		Task<Box> GetBoxAsync(string boxId, CancellationToken ct = default);
+		Task<Department> GetDepartmentAsync(string authToken, string orgId, string departmentId, CancellationToken ct = default);
+		Task UpdateOrganizationPropertiesAsync(string authToken, OrganizationPropertiesToUpdate orgProps, CancellationToken ct = default);
+		Task<OrganizationFeatures> GetOrganizationFeaturesAsync(string authToken, string boxId, CancellationToken ct = default);
+		Task<BoxEventList> GetNewEventsAsync(string authToken, string boxId, string afterEventId = null, CancellationToken ct = default);
+		Task<BoxEvent> GetEventAsync(string authToken, string boxId, string eventId, CancellationToken ct = default);
+		Task<Message> PostMessageAsync(string authToken, MessageToPost msg, string operationId = null, CancellationToken ct = default);
+		Task<Template> PostTemplateAsync(string authToken, TemplateToPost template, string operationId = null, CancellationToken ct = default);
 		Task<Message> TransformTemplateToMessageAsync(string authToken, TemplateTransformationToPost templateTransformation, string operationId
- = null);
-		Task<MessagePatch> PostMessagePatchAsync(string authToken, MessagePatchToPost patch, string operationId = null);
-		Task<MessagePatch> PostTemplatePatchAsync(string authToken, string boxId, string templateId, TemplatePatchToPost patch, string operationId = null);
-		Task PostRoamingNotificationAsync(string authToken, RoamingNotificationToPost notification);
-		Task DeleteAsync(string authToken, string boxId, string messageId, string documentId);
-		Task RestoreAsync(string authToken, string boxId, string messageId, string documentId);
-		Task MoveDocumentsAsync(string authToken, DocumentsMoveOperation query);
-		Task<byte[]> GetEntityContentAsync(string authToken, string boxId, string messageId, string entityId);
-		Task<GeneratedFile> GenerateDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer);
-		Task<GeneratedFile> GenerateInvoiceDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer);
-		Task<GeneratedFile> GenerateReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer);
-		Task<GeneratedFile> GenerateInvoiceCorrectionRequestXmlAsync(string authToken, string boxId, string messageId, string attachmentId, InvoiceCorrectionRequestInfo correctionInfo);
-		Task<GeneratedFile> GenerateRevocationRequestXmlAsync(string authToken, string boxId, string messageId, string attachmentId, RevocationRequestInfo revocationRequestInfo);
-		Task<GeneratedFile> GenerateSignatureRejectionXmlAsync(string authToken, string boxId, string messageId, string attachmentId, SignatureRejectionInfo signatureRejectionInfo);
-		Task<InvoiceCorrectionRequestInfo> GetInvoiceCorrectionRequestInfoAsync(string authToken, string boxId, string messageId, string entityId);
+ = null, CancellationToken ct = default);
+		Task<MessagePatch> PostMessagePatchAsync(string authToken, MessagePatchToPost patch, string operationId = null, CancellationToken ct = default);
+		Task<MessagePatch> PostTemplatePatchAsync(string authToken, string boxId, string templateId, TemplatePatchToPost patch, string operationId = null, CancellationToken ct = default);
+		Task PostRoamingNotificationAsync(string authToken, RoamingNotificationToPost notification, CancellationToken ct = default);
+		Task DeleteAsync(string authToken, string boxId, string messageId, string documentId, CancellationToken ct = default);
+		Task RestoreAsync(string authToken, string boxId, string messageId, string documentId, CancellationToken ct = default);
+		Task MoveDocumentsAsync(string authToken, DocumentsMoveOperation query, CancellationToken ct = default);
+		Task<byte[]> GetEntityContentAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateInvoiceDocumentReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateReceiptXmlAsync(string authToken, string boxId, string messageId, string attachmentId, Signer signer, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateInvoiceCorrectionRequestXmlAsync(string authToken, string boxId, string messageId, string attachmentId, InvoiceCorrectionRequestInfo correctionInfo, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateRevocationRequestXmlAsync(string authToken, string boxId, string messageId, string attachmentId, RevocationRequestInfo revocationRequestInfo, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateSignatureRejectionXmlAsync(string authToken, string boxId, string messageId, string attachmentId, SignatureRejectionInfo signatureRejectionInfo, CancellationToken ct = default);
+		Task<InvoiceCorrectionRequestInfo> GetInvoiceCorrectionRequestInfoAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateInvoiceXmlAsync(string authToken, InvoiceInfo invoiceInfo, bool disableValidation =
- false);
+ false, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateInvoiceRevisionXmlAsync(string authToken, InvoiceInfo invoiceRevisionInfo, bool disableValidation
- = false);
+ = false, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateInvoiceCorrectionXmlAsync(string authToken, InvoiceCorrectionInfo invoiceCorrectionInfo, bool disableValidation
- = false);
+ = false, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateInvoiceCorrectionRevisionXmlAsync(string authToken, InvoiceCorrectionInfo invoiceCorrectionRevision, bool disableValidation
- = false);
+ = false, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateTorg12XmlForSellerAsync(string authToken, Torg12SellerTitleInfo sellerInfo, bool disableValidation
- = false);
+ = false, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateTovTorg551XmlForSellerAsync(string authToken, TovTorgSellerTitleInfo sellerInfo, bool disableValidation
- = false);
-		Task<GeneratedFile> GenerateTorg12XmlForBuyerAsync(string authToken, Torg12BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId);
+ = false, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateTorg12XmlForBuyerAsync(string authToken, Torg12BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateTovTorg551XmlForBuyerAsync(string authToken, TovTorgBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, string documentVersion
- = null);
+ = null, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateAcceptanceCertificateXmlForSellerAsync(string authToken, AcceptanceCertificateSellerTitleInfo sellerInfo, bool disableValidation
- = false);
-		Task<GeneratedFile> GenerateAcceptanceCertificateXmlForBuyerAsync(string authToken, AcceptanceCertificateBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId);
+ = false, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateAcceptanceCertificateXmlForBuyerAsync(string authToken, AcceptanceCertificateBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForSellerAsync(string authToken, AcceptanceCertificate552SellerTitleInfo sellerInfo, bool disableValidation
- = false);
-		Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForBuyerAsync(string authToken, AcceptanceCertificate552BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId);
+ = false, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateAcceptanceCertificate552XmlForBuyerAsync(string authToken, AcceptanceCertificate552BuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateUniversalTransferDocumentXmlForSellerAsync(
 			string authToken,
 			UniversalTransferDocumentSellerTitleInfo sellerInfo,
 			bool disableValidation = false,
-			string documentVersion = null);
+			string documentVersion = null, 
+			CancellationToken ct = default);
 		Task<GeneratedFile> GenerateUniversalCorrectionDocumentXmlForSellerAsync(
 			string authToken,
 			UniversalCorrectionDocumentSellerTitleInfo sellerInfo,
 			bool disableValidation = false,
-			string documentVersion = null);
-		Task<GeneratedFile> GenerateUniversalTransferDocumentXmlForBuyerAsync(string authToken, UniversalTransferDocumentBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId);
-		Task<GeneratedFile> GenerateTitleXmlAsync(string authToken, string boxId, string documentTypeNamedId, string documentFunction, string documentVersion, int titleIndex, byte[] userContractData, bool disableValidation = false, string editingSettingId = null, string letterId = null, string documentId = null);
+			string documentVersion = null, 
+			CancellationToken ct = default);
+		Task<GeneratedFile> GenerateUniversalTransferDocumentXmlForBuyerAsync(string authToken, UniversalTransferDocumentBuyerTitleInfo buyerInfo, string boxId, string sellerTitleMessageId, string sellerTitleAttachmentId, CancellationToken ct = default);
+		Task<GeneratedFile> GenerateTitleXmlAsync(string authToken, string boxId, string documentTypeNamedId, string documentFunction, string documentVersion, int titleIndex, byte[] userContractData, bool disableValidation = false, string editingSettingId = null, string letterId = null, string documentId = null, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateSenderTitleXmlAsync(string authToken, string boxId, string documentTypeNamedId, string documentFunction, string documentVersion, byte[] userContractData, bool disableValidation
- = false, string editingSettingId = null);
+ = false, string editingSettingId = null, CancellationToken ct = default);
 		Task<GeneratedFile> GenerateRecipientTitleXmlAsync(string authToken, string boxId, string senderTitleMessageId, string senderTitleAttachmentId, byte[] userContractData, string documentVersion
- = null);
+ = null, CancellationToken ct = default);
 		Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, bool withOriginalSignature =
- false, bool injectEntityContent = false);
+ false, bool injectEntityContent = false, CancellationToken ct = default);
 		Task<Message> GetMessageAsync(string authToken, string boxId, string messageId, string entityId, bool withOriginalSignature
- = false, bool injectEntityContent = false);
-		Task<Template> GetTemplateAsync(string authToken, string boxId, string templateId, string entityId = null);
-		Task RecycleDraftAsync(string authToken, string boxId, string draftId);
-		Task<Message> SendDraftAsync(string authToken, DraftToSend draftToSend, string operationId = null);
-		Task<PrintFormResult> GeneratePrintFormAsync(string authToken, string boxId, string messageId, string documentId);
+ = false, bool injectEntityContent = false, CancellationToken ct = default);
+		Task<Template> GetTemplateAsync(string authToken, string boxId, string templateId, string entityId = null, CancellationToken ct = default);
+		Task RecycleDraftAsync(string authToken, string boxId, string draftId, CancellationToken ct = default);
+		Task<Message> SendDraftAsync(string authToken, DraftToSend draftToSend, string operationId = null, CancellationToken ct = default);
+		Task<PrintFormResult> GeneratePrintFormAsync(string authToken, string boxId, string messageId, string documentId, CancellationToken ct = default);
 		Task<string> GeneratePrintFormFromAttachmentAsync(string authToken, DocumentType documentType, byte[] content, string fromBoxId
- = null);
+ = null, CancellationToken ct = default);
 		[Obsolete("Use GetGeneratedPrintFormAsync without `documentType` parameter")]
-		Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, DocumentType documentType, string printFormId);
-		Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, string printFormId);
-		Task<string> RecognizeAsync(string fileName, byte[] content);
-		Task<Recognized> GetRecognizedAsync(string recognitionId);
+		Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, DocumentType documentType, string printFormId, CancellationToken ct = default);
+		Task<PrintFormResult> GetGeneratedPrintFormAsync(string authToken, string printFormId, CancellationToken ct = default);
+		Task<string> RecognizeAsync(string fileName, byte[] content, CancellationToken ct = default);
+		Task<Recognized> GetRecognizedAsync(string recognitionId, CancellationToken ct = default);
 		Task<DocumentList> GetDocumentsAsync(string authToken, string boxId, string filterCategory, string counteragentBoxId, DateTime? timestampFrom, DateTime? timestampTo, string fromDocumentDate, string toDocumentDate, string departmentId, bool excludeSubdepartments, string afterIndexKey, int? count
- = null);
-		Task<DocumentList> GetDocumentsAsync(string authToken, DocumentsFilter filter);
-		Task<Document> GetDocumentAsync(string authToken, string boxId, string messageId, string entityId);
-		Task<SignatureInfo> GetSignatureInfoAsync(string authToken, string boxId, string messageId, string entityId);
-		Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType);
-		Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType);
-		Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails);
-		Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails);
-		Task<GetDocflowBatchResponse> GetDocflowsAsync(string authToken, string boxId, GetDocflowBatchRequest request);
-		Task<GetDocflowEventsResponse> GetDocflowEventsAsync(string authToken, string boxId, GetDocflowEventsRequest request);
-		Task<SearchDocflowsResponse> SearchDocflowsAsync(string authToken, string boxId, SearchDocflowsRequest request);
-		Task<GetDocflowsByPacketIdResponse> GetDocflowsByPacketIdAsync(string authToken, string boxId, GetDocflowsByPacketIdRequest request);
-		Task<ForwardDocumentResponse> ForwardDocumentAsync(string authToken, string boxId, ForwardDocumentRequest request);
-		Task<GetForwardedDocumentsResponse> GetForwardedDocumentsAsync(string authToken, string boxId, GetForwardedDocumentsRequest request);
-		Task<GetForwardedDocumentEventsResponse> GetForwardedDocumentEventsAsync(string authToken, string boxId, GetForwardedDocumentEventsRequest request);
-		Task<byte[]> GetForwardedEntityContentAsync(string authToken, string boxId, ForwardedDocumentId forwardedDocumentId, string entityId);
-		Task<DocumentProtocolResult> GenerateForwardedDocumentProtocolAsync(string authToken, string boxId, ForwardedDocumentId forwardedDocumentId);
-		Task<PrintFormResult> GenerateForwardedDocumentPrintFormAsync(string authToken, string boxId, ForwardedDocumentId forwardedDocumentId);
-		Task<bool> CanSendInvoiceAsync(string authToken, string boxId, byte[] certificateBytes);
-		Task SendFnsRegistrationMessageAsync(string authToken, string boxId, FnsRegistrationMessageInfo fnsRegistrationMessageInfo);
-		Task<Counteragent> GetCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId);
-		Task<CounteragentCertificateList> GetCounteragentCertificatesAsync(string authToken, string myOrgId, string counteragentOrgId);
+ = null, CancellationToken ct = default);
+		Task<DocumentList> GetDocumentsAsync(string authToken, DocumentsFilter filter, CancellationToken ct = default);
+		Task<Document> GetDocumentAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default);
+		Task<SignatureInfo> GetSignatureInfoAsync(string authToken, string boxId, string messageId, string entityId, CancellationToken ct = default);
+		Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType, CancellationToken ct = default);
+		Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType, CancellationToken ct = default);
+		Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default);
+		Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, DocumentTitleType documentTitleType, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default);
+		Task<GetDocflowBatchResponse> GetDocflowsAsync(string authToken, string boxId, GetDocflowBatchRequest request, CancellationToken ct = default);
+		Task<GetDocflowEventsResponse> GetDocflowEventsAsync(string authToken, string boxId, GetDocflowEventsRequest request, CancellationToken ct = default);
+		Task<SearchDocflowsResponse> SearchDocflowsAsync(string authToken, string boxId, SearchDocflowsRequest request, CancellationToken ct = default);
+		Task<GetDocflowsByPacketIdResponse> GetDocflowsByPacketIdAsync(string authToken, string boxId, GetDocflowsByPacketIdRequest request, CancellationToken ct = default);
+		Task<ForwardDocumentResponse> ForwardDocumentAsync(string authToken, string boxId, ForwardDocumentRequest request, CancellationToken ct = default);
+		Task<GetForwardedDocumentsResponse> GetForwardedDocumentsAsync(string authToken, string boxId, GetForwardedDocumentsRequest request, CancellationToken ct = default);
+		Task<GetForwardedDocumentEventsResponse> GetForwardedDocumentEventsAsync(string authToken, string boxId, GetForwardedDocumentEventsRequest request, CancellationToken ct = default);
+		Task<byte[]> GetForwardedEntityContentAsync(string authToken, string boxId, ForwardedDocumentId forwardedDocumentId, string entityId, CancellationToken ct = default);
+		Task<DocumentProtocolResult> GenerateForwardedDocumentProtocolAsync(string authToken, string boxId, ForwardedDocumentId forwardedDocumentId, CancellationToken ct = default);
+		Task<PrintFormResult> GenerateForwardedDocumentPrintFormAsync(string authToken, string boxId, ForwardedDocumentId forwardedDocumentId, CancellationToken ct = default);
+		Task<bool> CanSendInvoiceAsync(string authToken, string boxId, byte[] certificateBytes, CancellationToken ct = default);
+		Task SendFnsRegistrationMessageAsync(string authToken, string boxId, FnsRegistrationMessageInfo fnsRegistrationMessageInfo, CancellationToken ct = default);
+		Task<Counteragent> GetCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId, CancellationToken ct = default);
+		Task<CounteragentCertificateList> GetCounteragentCertificatesAsync(string authToken, string myOrgId, string counteragentOrgId, CancellationToken ct = default);
 		Task<CounteragentList> GetCounteragentsAsync(string authToken, string myOrgId, string counteragentStatus, string afterIndexKey, string query
- = null, int? pageSize = null);
-		Task BreakWithCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId, string comment);
-		Task<string> UploadFileToShelfAsync(string authToken, byte[] data);
-		Task<byte[]> GetFileFromShelfAsync(string authToken, string nameOnShelf);
-		Task<RussianAddress> ParseRussianAddressAsync(string address);
+ = null, int? pageSize = null, CancellationToken ct = default);
+		Task BreakWithCounteragentAsync(string authToken, string myOrgId, string counteragentOrgId, string comment, CancellationToken ct = default);
+		Task<string> UploadFileToShelfAsync(string authToken, byte[] data, CancellationToken ct = default);
+		Task<byte[]> GetFileFromShelfAsync(string authToken, string nameOnShelf, CancellationToken ct = default);
+		Task<RussianAddress> ParseRussianAddressAsync(string address, CancellationToken ct = default);
 
-		Task<InvoiceInfo> ParseInvoiceXmlAsync(byte[] invoiceXmlContent);
-		Task<Torg12SellerTitleInfo> ParseTorg12SellerTitleXmlAsync(byte[] xmlContent);
-		Task<Torg12BuyerTitleInfo> ParseTorg12BuyerTitleXmlAsync(byte[] xmlContent);
-		Task<TovTorgSellerTitleInfo> ParseTovTorg551SellerTitleXmlAsync(byte[] xmlContent);
-		Task<TovTorgBuyerTitleInfo> ParseTovTorg551BuyerTitleXmlAsync(byte[] xmlContent);
-		Task<AcceptanceCertificateSellerTitleInfo> ParseAcceptanceCertificateSellerTitleXmlAsync(byte[] xmlContent);
-		Task<AcceptanceCertificateBuyerTitleInfo> ParseAcceptanceCertificateBuyerTitleXmlAsync(byte[] xmlContent);
-		Task<AcceptanceCertificate552SellerTitleInfo> ParseAcceptanceCertificate552SellerTitleXmlAsync(byte[] xmlContent);
-		Task<AcceptanceCertificate552BuyerTitleInfo> ParseAcceptanceCertificate552BuyerTitleXmlAsync(byte[] xmlContent);
-		Task<UniversalTransferDocumentSellerTitleInfo> ParseUniversalTransferDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Utd);
-		Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalTransferDocumentBuyerTitleXmlAsync(byte[] xmlContent);
-		Task<UniversalCorrectionDocumentSellerTitleInfo> ParseUniversalCorrectionDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Ucd);
-		Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalCorrectionDocumentBuyerTitleXmlAsync(byte[] xmlContent);
+		Task<InvoiceInfo> ParseInvoiceXmlAsync(byte[] invoiceXmlContent, CancellationToken ct = default);
+		Task<Torg12SellerTitleInfo> ParseTorg12SellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
+		Task<Torg12BuyerTitleInfo> ParseTorg12BuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
+		Task<TovTorgSellerTitleInfo> ParseTovTorg551SellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
+		Task<TovTorgBuyerTitleInfo> ParseTovTorg551BuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
+		Task<AcceptanceCertificateSellerTitleInfo> ParseAcceptanceCertificateSellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
+		Task<AcceptanceCertificateBuyerTitleInfo> ParseAcceptanceCertificateBuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
+		Task<AcceptanceCertificate552SellerTitleInfo> ParseAcceptanceCertificate552SellerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
+		Task<AcceptanceCertificate552BuyerTitleInfo> ParseAcceptanceCertificate552BuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
+		Task<UniversalTransferDocumentSellerTitleInfo> ParseUniversalTransferDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Utd, CancellationToken ct = default);
+		Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalTransferDocumentBuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
+		Task<UniversalCorrectionDocumentSellerTitleInfo> ParseUniversalCorrectionDocumentSellerTitleXmlAsync(byte[] xmlContent, string documentVersion = DefaultDocumentVersions.Ucd, CancellationToken ct = default);
+		Task<UniversalTransferDocumentBuyerTitleInfo> ParseUniversalCorrectionDocumentBuyerTitleXmlAsync(byte[] xmlContent, CancellationToken ct = default);
 
 		Task<byte[]> ParseTitleXmlAsync(
 			string authToken,
@@ -384,67 +387,68 @@ Task<byte[]> ParseTitleXmlAsync(
 			string documentFunction,
 			string documentVersion,
 			int titleIndex,
-			byte[] content);
+			byte[] content, 
+			CancellationToken ct = default);
 
-		Task<OrganizationUsersList> GetOrganizationUsersAsync(string authToken, string orgId);
-		Task<List<Organization>> GetOrganizationsByInnListAsync(GetOrganizationsByInnListRequest innList);
-		Task<List<OrganizationWithCounteragentStatus>> GetOrganizationsByInnListAsync(string authToken, string myOrgId, GetOrganizationsByInnListRequest innList);
-		Task<RevocationRequestInfo> ParseRevocationRequestXmlAsync(byte[] revocationRequestXmlContent);
-		Task<SignatureRejectionInfo> ParseSignatureRejectionXmlAsync(byte[] signatureRejectionXmlContent);
-		Task<DocumentProtocolResult> GenerateDocumentProtocolAsync(string authToken, string boxId, string messageId, string documentId);
-		Task<DocumentZipGenerationResult> GenerateDocumentZipAsync(string authToken, string boxId, string messageId, string documentId, bool fullDocflow);
-		Task<DocumentList> GetDocumentsByCustomIdAsync(string authToken, string boxId, string customDocumentId);
+		Task<OrganizationUsersList> GetOrganizationUsersAsync(string authToken, string orgId, CancellationToken ct = default);
+		Task<List<Organization>> GetOrganizationsByInnListAsync(GetOrganizationsByInnListRequest innList, CancellationToken ct = default);
+		Task<List<OrganizationWithCounteragentStatus>> GetOrganizationsByInnListAsync(string authToken, string myOrgId, GetOrganizationsByInnListRequest innList, CancellationToken ct = default);
+		Task<RevocationRequestInfo> ParseRevocationRequestXmlAsync(byte[] revocationRequestXmlContent, CancellationToken ct = default);
+		Task<SignatureRejectionInfo> ParseSignatureRejectionXmlAsync(byte[] signatureRejectionXmlContent, CancellationToken ct = default);
+		Task<DocumentProtocolResult> GenerateDocumentProtocolAsync(string authToken, string boxId, string messageId, string documentId, CancellationToken ct = default);
+		Task<DocumentZipGenerationResult> GenerateDocumentZipAsync(string authToken, string boxId, string messageId, string documentId, bool fullDocflow, CancellationToken ct = default);
+		Task<DocumentList> GetDocumentsByCustomIdAsync(string authToken, string boxId, string customDocumentId, CancellationToken ct = default);
 		Task<PrepareDocumentsToSignResponse> PrepareDocumentsToSignAsync(string authToken, PrepareDocumentsToSignRequest request, bool excludeContent
- = false);
-		Task<AsyncMethodResult> CloudSignAsync(string authToken, CloudSignRequest request, string certificateThumbprint);
-		Task<CloudSignResult> WaitCloudSignResultAsync(string authToken, string taskId, TimeSpan? timeout = null);
+ = false, CancellationToken ct = default);
+		Task<AsyncMethodResult> CloudSignAsync(string authToken, CloudSignRequest request, string certificateThumbprint, CancellationToken ct = default);
+		Task<CloudSignResult> WaitCloudSignResultAsync(string authToken, string taskId, TimeSpan? timeout = null, CancellationToken ct = default);
 		Task<AsyncMethodResult> CloudSignConfirmAsync(string authToken, string cloudSignToken, string confirmationCode, ContentLocationPreference? locationPreference
- = null);
+ = null, CancellationToken ct = default);
 		Task<CloudSignConfirmResult> WaitCloudSignConfirmResultAsync(string authToken, string taskId, TimeSpan? timeout
- = null);
-		Task<AsyncMethodResult> DssSignAsync(string authToken, string boxId, DssSignRequest request, string certificateThumbprint = null);
-		Task<DssSignResult> DssSignResultAsync(string authToken, string boxId, string taskId);
+ = null, CancellationToken ct = default);
+		Task<AsyncMethodResult> DssSignAsync(string authToken, string boxId, DssSignRequest request, string certificateThumbprint = null, CancellationToken ct = default);
+		Task<DssSignResult> DssSignResultAsync(string authToken, string boxId, string taskId, CancellationToken ct = default);
 		Task<AsyncMethodResult> AcquireCounteragentAsync(string authToken, string myOrgId, AcquireCounteragentRequest request, string myDepartmentId
- = null);
+ = null, CancellationToken ct = default);
 		Task<AcquireCounteragentResult> WaitAcquireCounteragentResultAsync(string authToken, string taskId, TimeSpan? timeout
- = null, TimeSpan? delay = null);
-		Task<DocumentList> GetDocumentsByMessageIdAsync(string authToken, string boxId, string messageId);
-		Task<List<KeyValueStorageEntry>> GetOrganizationStorageEntriesAsync(string authToken, string boxId, IEnumerable<string> keys);
-		Task PutOrganizationStorageEntriesAsync(string authToken, string boxId, IEnumerable<KeyValueStorageEntry> entries);
-		Task<AsyncMethodResult> AutoSignReceiptsAsync(string authToken, string boxId, string certificateThumbprint, string batchKey);
+ = null, TimeSpan? delay = null, CancellationToken ct = default);
+		Task<DocumentList> GetDocumentsByMessageIdAsync(string authToken, string boxId, string messageId, CancellationToken ct = default);
+		Task<List<KeyValueStorageEntry>> GetOrganizationStorageEntriesAsync(string authToken, string boxId, IEnumerable<string> keys, CancellationToken ct = default);
+		Task PutOrganizationStorageEntriesAsync(string authToken, string boxId, IEnumerable<KeyValueStorageEntry> entries, CancellationToken ct = default);
+		Task<AsyncMethodResult> AutoSignReceiptsAsync(string authToken, string boxId, string certificateThumbprint, string batchKey, CancellationToken ct = default);
 		Task<AutosignReceiptsResult> WaitAutosignReceiptsResultAsync(string authToken, string taskId, TimeSpan? timeout
- = null);
-		Task<ExternalServiceAuthInfo> GetExternalServiceAuthInfoAsync(string key);
-		Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection);
-		Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection);
-		Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails);
-		Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails);
-		Task<ResolutionRouteList> GetResolutionRoutesForOrganizationAsync(string authToken, string orgId);
-		Task<GetDocumentTypesResponse> GetDocumentTypesAsync(string authToken, string boxId);
-		Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, string nameOnShelf);
-		Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, byte[] content);
-		Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, string nameOnShelf);
-		Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, byte[] content);
+ = null, CancellationToken ct = default);
+		Task<ExternalServiceAuthInfo> GetExternalServiceAuthInfoAsync(string key, CancellationToken ct = default);
+		Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection, CancellationToken ct = default);
+		Task<ExtendedSignerDetails> GetExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection, CancellationToken ct = default);
+		Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, string thumbprint, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default);
+		Task<ExtendedSignerDetails> PostExtendedSignerDetailsAsync(string token, string boxId, byte[] certificateBytes, bool forBuyer, bool forCorrection, ExtendedSignerDetailsToPost signerDetails, CancellationToken ct = default);
+		Task<ResolutionRouteList> GetResolutionRoutesForOrganizationAsync(string authToken, string orgId, CancellationToken ct = default);
+		Task<GetDocumentTypesResponse> GetDocumentTypesAsync(string authToken, string boxId, CancellationToken ct = default);
+		Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, string nameOnShelf, CancellationToken ct = default);
+		Task<DetectDocumentTypesResponse> DetectDocumentTypesAsync(string authToken, string boxId, byte[] content, CancellationToken ct = default);
+		Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, string nameOnShelf, CancellationToken ct = default);
+		Task<DetectTitleResponse> DetectDocumentTitlesAsync(string authToken, string boxId, byte[] content, CancellationToken ct = default);
 		[Obsolete("In order to download XSD schema use the link provided in DocumentTitle.XsdUrl")]
-		Task<FileContent> GetContentAsync(string authToken, string typeNamedId, string function, string version, int titleIndex, XsdContentType contentType = default(XsdContentType));
-		Task<Employee> GetEmployeeAsync(string authToken, string boxId, string userId);
-		Task<EmployeeList> GetEmployeesAsync(string authToken, string boxId, int? page, int? count);
-		Task<Employee> CreateEmployeeAsync(string authToken, string boxId, EmployeeToCreate employeeToCreate);
-		Task<Employee> UpdateEmployeeAsync(string authToken, string boxId, string userId, EmployeeToUpdate employeeToUpdate);
-		Task DeleteEmployeeAsync(string authToken, string boxId, string userId);
-		Task<Employee> GetMyEmployeeAsync(string authToken, string boxId);
-		Task<EmployeeSubscriptions> GetSubscriptionsAsync(string authToken, string boxId, string userId);
-		Task<EmployeeSubscriptions> UpdateSubscriptionsAsync(string authToken, string boxId, string userId, SubscriptionsToUpdate subscriptionsToUpdate);
-		Task<Departments.Department> GetDepartmentByFullIdAsync(string authToken, string boxId, string departmentId);
+		Task<FileContent> GetContentAsync(string authToken, string typeNamedId, string function, string version, int titleIndex, XsdContentType contentType = default(XsdContentType), CancellationToken ct = default);
+		Task<Employee> GetEmployeeAsync(string authToken, string boxId, string userId, CancellationToken ct = default);
+		Task<EmployeeList> GetEmployeesAsync(string authToken, string boxId, int? page, int? count, CancellationToken ct = default);
+		Task<Employee> CreateEmployeeAsync(string authToken, string boxId, EmployeeToCreate employeeToCreate, CancellationToken ct = default);
+		Task<Employee> UpdateEmployeeAsync(string authToken, string boxId, string userId, EmployeeToUpdate employeeToUpdate, CancellationToken ct = default);
+		Task DeleteEmployeeAsync(string authToken, string boxId, string userId, CancellationToken ct = default);
+		Task<Employee> GetMyEmployeeAsync(string authToken, string boxId, CancellationToken ct = default);
+		Task<EmployeeSubscriptions> GetSubscriptionsAsync(string authToken, string boxId, string userId, CancellationToken ct = default);
+		Task<EmployeeSubscriptions> UpdateSubscriptionsAsync(string authToken, string boxId, string userId, SubscriptionsToUpdate subscriptionsToUpdate, CancellationToken ct = default);
+		Task<Departments.Department> GetDepartmentByFullIdAsync(string authToken, string boxId, string departmentId, CancellationToken ct = default);
 		Task<Departments.DepartmentList> GetDepartmentsAsync(string authToken, string boxId, int? page =
- null, int? count = null);
-		Task<Departments.Department> CreateDepartmentAsync(string authToken, string boxId, Departments.DepartmentToCreate departmentToCreate);
-		Task<Departments.Department> UpdateDepartmentAsync(string authToken, string boxId, string departmentId, Departments.DepartmentToUpdate departmentToUpdate);
-		Task DeleteDepartmentAsync(string authToken, string boxId, string departmentId);
-		Task<RegistrationResponse> RegisterAsync(string authToken, RegistrationRequest registrationRequest);
-		Task RegisterConfirmAsync(string authToken, RegistrationConfirmRequest registrationConfirmRequest);
-		Task<CustomPrintFormDetectionResult> DetectCustomPrintFormsAsync(string authToken, string boxId, CustomPrintFormDetectionRequest request);
-		Task<BoxEvent> GetLastEventAsync(string authToken, string boxId);
+ null, int? count = null, CancellationToken ct = default);
+		Task<Departments.Department> CreateDepartmentAsync(string authToken, string boxId, Departments.DepartmentToCreate departmentToCreate, CancellationToken ct = default);
+		Task<Departments.Department> UpdateDepartmentAsync(string authToken, string boxId, string departmentId, Departments.DepartmentToUpdate departmentToUpdate, CancellationToken ct = default);
+		Task DeleteDepartmentAsync(string authToken, string boxId, string departmentId, CancellationToken ct = default);
+		Task<RegistrationResponse> RegisterAsync(string authToken, RegistrationRequest registrationRequest, CancellationToken ct = default);
+		Task RegisterConfirmAsync(string authToken, RegistrationConfirmRequest registrationConfirmRequest, CancellationToken ct = default);
+		Task<CustomPrintFormDetectionResult> DetectCustomPrintFormsAsync(string authToken, string boxId, CustomPrintFormDetectionRequest request, CancellationToken ct = default);
+		Task<BoxEvent> GetLastEventAsync(string authToken, string boxId, CancellationToken ct = default);
 #endif
 	}
 }
\ No newline at end of file
diff --git a/src/IDocflowApi.cs b/src/IDocflowApi.cs
index f2bcc316..d6adf66c 100644
--- a/src/IDocflowApi.cs
+++ b/src/IDocflowApi.cs
@@ -1,6 +1,7 @@
 using Diadoc.Api.Proto.Docflow;
 
 #if !NET35
+using System.Threading;
 using System.Threading.Tasks;
 #endif
 
@@ -14,10 +15,10 @@ public interface IDocflowApi
 		GetDocflowsByPacketIdResponseV3 GetDocflowsByPacketId(string authToken, string boxId, GetDocflowsByPacketIdRequest request);
 
 #if !NET35
-		Task<GetDocflowBatchResponseV3> GetDocflowsAsync(string authToken, string boxId, GetDocflowBatchRequest request);
-		Task<GetDocflowEventsResponseV3> GetDocflowEventsAsync(string authToken, string boxId, GetDocflowEventsRequest request);
-		Task<SearchDocflowsResponseV3> SearchDocflowsAsync(string authToken, string boxId, SearchDocflowsRequest request);
-		Task<GetDocflowsByPacketIdResponseV3> GetDocflowsByPacketIdAsync(string authToken, string boxId, GetDocflowsByPacketIdRequest request);
+		Task<GetDocflowBatchResponseV3> GetDocflowsAsync(string authToken, string boxId, GetDocflowBatchRequest request, CancellationToken ct = default);
+		Task<GetDocflowEventsResponseV3> GetDocflowEventsAsync(string authToken, string boxId, GetDocflowEventsRequest request, CancellationToken ct = default);
+		Task<SearchDocflowsResponseV3> SearchDocflowsAsync(string authToken, string boxId, SearchDocflowsRequest request, CancellationToken ct = default);
+		Task<GetDocflowsByPacketIdResponseV3> GetDocflowsByPacketIdAsync(string authToken, string boxId, GetDocflowsByPacketIdRequest request, CancellationToken ct = default);
 #endif
 	}
 }
\ No newline at end of file
diff --git a/src/WebRequestExtensions.cs b/src/WebRequestExtensions.cs
new file mode 100644
index 00000000..13eb783d
--- /dev/null
+++ b/src/WebRequestExtensions.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Net;
+
+#if !NET35
+using System.Threading;
+using System.Threading.Tasks;
+#endif
+
+namespace Diadoc.Api
+{
+    public static class WebRequestExtensions
+    {
+#if !NET35
+        public static async Task<WebResponse> GetResponseAsync(this WebRequest request, CancellationToken ct = default)
+        {
+            using (ct.Register(request.Abort, useSynchronizationContext: false))
+            {
+                try
+                {
+                    var response = await request.GetResponseAsync();
+                    return response;
+                }
+                catch (WebException ex)
+                {
+                    // WebException is thrown when request.Abort() is called,
+                    // but there may be many other reasons,
+                    // propagate the WebException to the caller correctly
+                    if (ct.IsCancellationRequested)
+                    {
+                        // the WebException will be available as Exception.InnerException
+                        throw new OperationCanceledException(ex.Message, ex, ct);
+                    }
+
+                    // cancellation hasn't been requested, rethrow the original WebException
+                    throw;
+                }
+            }
+        }
+#endif
+    }
+}
\ No newline at end of file
diff --git a/tests/DiadocApi-Tests.csproj b/tests/DiadocApi-Tests.csproj
index 523ee14b..d20394df 100644
--- a/tests/DiadocApi-Tests.csproj
+++ b/tests/DiadocApi-Tests.csproj
@@ -8,6 +8,7 @@
   </PropertyGroup>
 
   <ItemGroup Condition="$(TargetFramework) == 'net35' or $(TargetFramework) == 'net40'">
+    <Compile Remove="TaskAsyncronousCancel_Test.cs" />
     <Compile Remove="TaskAsyncronousPattern_Test.cs" />
   </ItemGroup>
 
@@ -22,4 +23,20 @@
   <ItemGroup>
     <ProjectReference Include="..\src\DiadocApi.csproj" />
   </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net45'">
+    <PackageReference Include="NSubstitute" Version="4.2.2" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net461'">
+    <PackageReference Include="NSubstitute" Version="4.2.2" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'net472'">
+    <PackageReference Include="NSubstitute" Version="4.2.2" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp2.2'">
+    <PackageReference Include="NSubstitute" Version="4.2.2" />
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/tests/TaskAsyncronousCancel_Test.cs b/tests/TaskAsyncronousCancel_Test.cs
new file mode 100644
index 00000000..e3bc402b
--- /dev/null
+++ b/tests/TaskAsyncronousCancel_Test.cs
@@ -0,0 +1,71 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace Diadoc.Api.Tests
+{
+	[TestFixture]
+	public class TaskAsyncronousCancel_Test
+	{
+		[TestCase(0, 5000)]
+		[TestCase(1, 5000)]
+		[TestCase(1000, 5000)]
+		[TestCase(10000, 5000)]
+		[TestCase(15000, 5000)]
+		public async Task ShouldThrowOperationCanceledExceptionWhenIsCancellationRequested(int ms, int delay)
+		{
+			var cts = new CancellationTokenSource();
+			cts.CancelAfter(TimeSpan.FromMilliseconds(ms));
+			
+			var mock = Substitute.For<IDiadocApi>();
+
+			mock.AuthenticateAsync(null, null, ct: cts.Token)
+				.ReturnsForAnyArgs(x => string.Empty)
+				.AndDoes(x =>
+				{
+					Thread.Sleep(delay);
+					var ct = x.Arg<CancellationToken>();
+					if (ct.IsCancellationRequested)
+					{
+						throw new OperationCanceledException();
+					}
+				});
+			
+			if (ms > delay)
+			{
+				Assert.AreEqual(string.Empty, await mock.AuthenticateAsync(null, null, ct: cts.Token));
+			}
+			else
+			{
+				Assert.ThrowsAsync<OperationCanceledException>(async () => await mock.AuthenticateAsync(null, null, ct: cts.Token));
+			}
+		}
+		
+		[TestCase(0, 5000)]
+		[TestCase(1, 5000)]
+		[TestCase(1000, 5000)]
+		[TestCase(10000, 5000)]
+		[TestCase(15000, 5000)]
+		public async Task ShouldThrowTaskCanceledExceptionWhenTokenPassedToNestedMethod(int ms, int delay)
+		{
+			var cts = new CancellationTokenSource();
+			cts.CancelAfter(TimeSpan.FromMilliseconds(ms));
+			
+			var mock = Substitute.For<IDiadocApi>();
+
+			var delayedResult = Task.Delay(delay, cts.Token).ContinueWith(_ => string.Empty, cts.Token);
+			mock.AuthenticateAsync(null, null, ct: cts.Token).Returns(delayedResult);
+			
+			if (ms > delay)
+			{
+				Assert.AreEqual(string.Empty, await mock.AuthenticateAsync(null, null, ct: cts.Token));
+			}
+			else
+			{
+				Assert.ThrowsAsync<TaskCanceledException>(async () => await mock.AuthenticateAsync(null, null, ct: cts.Token));
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/TaskAsyncronousPattern_Test.cs b/tests/TaskAsyncronousPattern_Test.cs
index dfb9ef88..03d69be7 100644
--- a/tests/TaskAsyncronousPattern_Test.cs
+++ b/tests/TaskAsyncronousPattern_Test.cs
@@ -3,6 +3,7 @@
 using System.Globalization;
 using System.Linq;
 using System.Reflection;
+using System.Threading;
 using System.Threading.Tasks;
 using NUnit.Framework;
 
@@ -26,9 +27,10 @@ public void AllTapMethodsMustReturnTask(MethodInfo method)
 		[TestCaseSource(nameof(GetAllSynchronousApiMethods))]
 		public void AllSynchronousApiMethodsShouldHaveAsyncCounterpartWithSameSignature(MethodInfo method)
 		{
-			var methodParameters = method.GetParameters().Select(x => x.ParameterType).ToArray();
+			var methodParameters = method.GetParameters().Select(x => x.ParameterType).ToList();
+			methodParameters.Add(typeof(CancellationToken));
 			var methodName = method.Name;
-			var asyncMethodCounterpart = method.ReflectedType?.GetMethod(methodName + "Async", methodParameters);
+			var asyncMethodCounterpart = method.ReflectedType?.GetMethod(methodName + "Async", methodParameters.ToArray());
 			Assert.NotNull(asyncMethodCounterpart, $"Type: {method.ReflectedType}, Method: {method} has no async counterpart");
 			if (method.ReturnType == typeof(void))
 				Assert.That(asyncMethodCounterpart.ReturnType, Is.EqualTo(typeof(Task)), $"Type: {method.ReflectedType}, Method: {method} async counterpart has wrong return type");
@@ -41,7 +43,7 @@ public void AllSynchronousApiMethodsShouldHaveAsyncCounterpartWithSameSignature(
 		[TestCaseSource(nameof(GetAllAsynchronousApiMethods))]
 		public void AllAsynchronousApiMethodsShouldHaveSyncCounterpartWithSameSignature(MethodInfo method)
 		{
-			var methodParameters = method.GetParameters().Select(x => x.ParameterType).ToArray();
+			var methodParameters = method.GetParameters().Select(x => x.ParameterType).Where(x=> x != typeof(CancellationToken)).ToArray();
 			var methodNameWithoutAsync = method.Name.Substring(0, method.Name.Length - "Async".Length);
 			var syncMethodCounterpart = method.ReflectedType?.GetMethod(methodNameWithoutAsync, methodParameters);
 			Assert.NotNull(syncMethodCounterpart, $"Type: {method.ReflectedType}, Method: {method} has no synchronous counterpart");
@@ -68,7 +70,7 @@ public void AllDiadocHttpApiMethodsShouldHaveCounterpartsInIDiadocApi(MethodInfo
 			Assert.NotNull(counterpart, method + " have no counterpart in IDiadocApi interface");
 			Assert.That(counterpart.ReturnType, Is.EqualTo(method.ReturnType));
 		}
-
+		
 		private static IEnumerable<MethodInfo> GetAllTapMethods()
 		{
 			var diadocApiTypes = typeof(IDiadocApi).Assembly.GetExportedTypes();