sochix/TLSharp
1
0
Fork 0
mirror of https://github.com/sochix/TLSharp.git synced 2026-01-11 19:30:06 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

api: Update to Layer 108

Browse source
This commit is contained in:
Afshin Arani 2020-04-03 11:53:02 +04:30 committed by Andres G. Aragoneses
parent 58df196e08
commit 07c4812e99
679 changed files with 20064 additions and 2181 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/TeleSharp.TL/TL/Account/TLAbsPassword.cs → src/TeleSharp.TL/TL/Account/TLAbsThemes.cs
View file

@ -7,7 +7,7 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
public abstract class TLAbsPassword : TLObject
public abstract class TLAbsThemes : TLObject
{
}
}

13
src/TeleSharp.TL/TL/Account/TLAbsWallPapers.cs Normal file
View file

@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
public abstract class TLAbsWallPapers : TLObject
{
}
}

62
src/TeleSharp.TL/TL/Account/TLAuthorizationForm.cs Normal file
View file

@ -0,0 +1,62 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1389486888)]
public class TLAuthorizationForm : TLObject
{
public override int Constructor
{
get
{
return -1389486888;
}
}
public int Flags { get; set; }
public TLVector<TLAbsSecureRequiredType> RequiredTypes { get; set; }
public TLVector<TLSecureValue> Values { get; set; }
public TLVector<TLAbsSecureValueError> Errors { get; set; }
public TLVector<TLAbsUser> Users { get; set; }
public string PrivacyPolicyUrl { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
RequiredTypes = (TLVector<TLAbsSecureRequiredType>)ObjectUtils.DeserializeVector<TLAbsSecureRequiredType>(br);
Values = (TLVector<TLSecureValue>)ObjectUtils.DeserializeVector<TLSecureValue>(br);
Errors = (TLVector<TLAbsSecureValueError>)ObjectUtils.DeserializeVector<TLAbsSecureValueError>(br);
Users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
if ((Flags & 1) != 0)
PrivacyPolicyUrl = StringUtil.Deserialize(br);
else
PrivacyPolicyUrl = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
ObjectUtils.SerializeObject(RequiredTypes, bw);
ObjectUtils.SerializeObject(Values, bw);
ObjectUtils.SerializeObject(Errors, bw);
ObjectUtils.SerializeObject(Users, bw);
if ((Flags & 1) != 0)
StringUtil.Serialize(PrivacyPolicyUrl, bw);
}
}
}

48
src/TeleSharp.TL/TL/Account/TLAutoDownloadSettings.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1674235686)]
public class TLAutoDownloadSettings : TLObject
{
public override int Constructor
{
get
{
return 1674235686;
}
}
public TLAutoDownloadSettings Low { get; set; }
public TLAutoDownloadSettings Medium { get; set; }
public TLAutoDownloadSettings High { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Low = (TLAutoDownloadSettings)ObjectUtils.DeserializeObject(br);
Medium = (TLAutoDownloadSettings)ObjectUtils.DeserializeObject(br);
High = (TLAutoDownloadSettings)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Low, bw);
ObjectUtils.SerializeObject(Medium, bw);
ObjectUtils.SerializeObject(High, bw);
}
}
}

21
src/TeleSharp.TL/TL/Account/TLNoPassword.cs → src/TeleSharp.TL/TL/Account/TLContentSettings.cs
View file

@ -7,19 +7,20 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1764049896)]
public class TLNoPassword : TLAbsPassword
[TLObject(1474462241)]
public class TLContentSettings : TLObject
{
public override int Constructor
{
get
{
return -1764049896;
return 1474462241;
}
}
public byte[] NewSalt { get; set; }
public string EmailUnconfirmedPattern { get; set; }
public int Flags { get; set; }
public bool SensitiveEnabled { get; set; }
public bool SensitiveCanChange { get; set; }
public void ComputeFlags()
@ -29,16 +30,18 @@ namespace TeleSharp.TL.Account
public override void DeserializeBody(BinaryReader br)
{
NewSalt = BytesUtil.Deserialize(br);
EmailUnconfirmedPattern = StringUtil.Deserialize(br);
Flags = br.ReadInt32();
SensitiveEnabled = (Flags & 1) != 0;
SensitiveCanChange = (Flags & 2) != 0;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BytesUtil.Serialize(NewSalt, bw);
StringUtil.Serialize(EmailUnconfirmedPattern, bw);
bw.Write(Flags);
}
}

78
src/TeleSharp.TL/TL/Account/TLPassword.cs
View file

@ -7,22 +7,29 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(2081952796)]
public class TLPassword : TLAbsPassword
[TLObject(-1390001672)]
public class TLPassword : TLObject
{
public override int Constructor
{
get
{
return 2081952796;
return -1390001672;
}
}
public byte[] CurrentSalt { get; set; }
public byte[] NewSalt { get; set; }
public string Hint { get; set; }
public int Flags { get; set; }
public bool HasRecovery { get; set; }
public bool HasSecureValues { get; set; }
public bool HasPassword { get; set; }
public TLAbsPasswordKdfAlgo CurrentAlgo { get; set; }
public byte[] SrpB { get; set; }
public long? SrpId { get; set; }
public string Hint { get; set; }
public string EmailUnconfirmedPattern { get; set; }
public TLAbsPasswordKdfAlgo NewAlgo { get; set; }
public TLAbsSecurePasswordKdfAlgo NewSecureAlgo { get; set; }
public byte[] SecureRandom { get; set; }
public void ComputeFlags()
@ -32,22 +39,61 @@ namespace TeleSharp.TL.Account
public override void DeserializeBody(BinaryReader br)
{
CurrentSalt = BytesUtil.Deserialize(br);
NewSalt = BytesUtil.Deserialize(br);
Hint = StringUtil.Deserialize(br);
HasRecovery = BoolUtil.Deserialize(br);
EmailUnconfirmedPattern = StringUtil.Deserialize(br);
Flags = br.ReadInt32();
HasRecovery = (Flags & 1) != 0;
HasSecureValues = (Flags & 2) != 0;
HasPassword = (Flags & 4) != 0;
if ((Flags & 4) != 0)
CurrentAlgo = (TLAbsPasswordKdfAlgo)ObjectUtils.DeserializeObject(br);
else
CurrentAlgo = null;
if ((Flags & 4) != 0)
SrpB = BytesUtil.Deserialize(br);
else
SrpB = null;
if ((Flags & 4) != 0)
SrpId = br.ReadInt64();
else
SrpId = null;
if ((Flags & 8) != 0)
Hint = StringUtil.Deserialize(br);
else
Hint = null;
if ((Flags & 16) != 0)
EmailUnconfirmedPattern = StringUtil.Deserialize(br);
else
EmailUnconfirmedPattern = null;
NewAlgo = (TLAbsPasswordKdfAlgo)ObjectUtils.DeserializeObject(br);
NewSecureAlgo = (TLAbsSecurePasswordKdfAlgo)ObjectUtils.DeserializeObject(br);
SecureRandom = BytesUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BytesUtil.Serialize(CurrentSalt, bw);
BytesUtil.Serialize(NewSalt, bw);
StringUtil.Serialize(Hint, bw);
BoolUtil.Serialize(HasRecovery, bw);
StringUtil.Serialize(EmailUnconfirmedPattern, bw);
bw.Write(Flags);
if ((Flags & 4) != 0)
ObjectUtils.SerializeObject(CurrentAlgo, bw);
if ((Flags & 4) != 0)
BytesUtil.Serialize(SrpB, bw);
if ((Flags & 4) != 0)
bw.Write(SrpId.Value);
if ((Flags & 8) != 0)
StringUtil.Serialize(Hint, bw);
if ((Flags & 16) != 0)
StringUtil.Serialize(EmailUnconfirmedPattern, bw);
ObjectUtils.SerializeObject(NewAlgo, bw);
ObjectUtils.SerializeObject(NewSecureAlgo, bw);
BytesUtil.Serialize(SecureRandom, bw);
}
}

26
src/TeleSharp.TL/TL/Account/TLPasswordInputSettings.cs
View file

@ -7,31 +7,27 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-2037289493)]
[TLObject(-1036572727)]
public class TLPasswordInputSettings : TLObject
{
public override int Constructor
{
get
{
return -2037289493;
return -1036572727;
}
}
public int Flags { get; set; }
public byte[] NewSalt { get; set; }
public TLAbsPasswordKdfAlgo NewAlgo { get; set; }
public byte[] NewPasswordHash { get; set; }
public string Hint { get; set; }
public string Email { get; set; }
public TLSecureSecretSettings NewSecureSettings { get; set; }
public void ComputeFlags()
{
Flags = 0;
Flags = NewSalt != null ? (Flags | 1) : (Flags & ~1);
Flags = NewPasswordHash != null ? (Flags | 1) : (Flags & ~1);
Flags = Hint != null ? (Flags | 1) : (Flags & ~1);
Flags = Email != null ? (Flags | 2) : (Flags & ~2);
}
@ -39,9 +35,9 @@ namespace TeleSharp.TL.Account
{
Flags = br.ReadInt32();
if ((Flags & 1) != 0)
NewSalt = BytesUtil.Deserialize(br);
NewAlgo = (TLAbsPasswordKdfAlgo)ObjectUtils.DeserializeObject(br);
else
NewSalt = null;
NewAlgo = null;
if ((Flags & 1) != 0)
NewPasswordHash = BytesUtil.Deserialize(br);
@ -58,22 +54,28 @@ namespace TeleSharp.TL.Account
else
Email = null;
if ((Flags & 4) != 0)
NewSecureSettings = (TLSecureSecretSettings)ObjectUtils.DeserializeObject(br);
else
NewSecureSettings = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
if ((Flags & 1) != 0)
BytesUtil.Serialize(NewSalt, bw);
ObjectUtils.SerializeObject(NewAlgo, bw);
if ((Flags & 1) != 0)
BytesUtil.Serialize(NewPasswordHash, bw);
if ((Flags & 1) != 0)
StringUtil.Serialize(Hint, bw);
if ((Flags & 2) != 0)
StringUtil.Serialize(Email, bw);
if ((Flags & 4) != 0)
ObjectUtils.SerializeObject(NewSecureSettings, bw);
}
}

24
src/TeleSharp.TL/TL/Account/TLPasswordSettings.cs
View file

@ -7,18 +7,20 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1212732749)]
[TLObject(-1705233435)]
public class TLPasswordSettings : TLObject
{
public override int Constructor
{
get
{
return -1212732749;
return -1705233435;
}
}
public int Flags { get; set; }
public string Email { get; set; }
public TLSecureSecretSettings SecureSettings { get; set; }
public void ComputeFlags()
@ -28,14 +30,28 @@ namespace TeleSharp.TL.Account
public override void DeserializeBody(BinaryReader br)
{
Email = StringUtil.Deserialize(br);
Flags = br.ReadInt32();
if ((Flags & 1) != 0)
Email = StringUtil.Deserialize(br);
else
Email = null;
if ((Flags & 2) != 0)
SecureSettings = (TLSecureSecretSettings)ObjectUtils.DeserializeObject(br);
else
SecureSettings = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
StringUtil.Serialize(Email, bw);
bw.Write(Flags);
if ((Flags & 1) != 0)
StringUtil.Serialize(Email, bw);
if ((Flags & 2) != 0)
ObjectUtils.SerializeObject(SecureSettings, bw);
}
}

7
src/TeleSharp.TL/TL/Account/TLPrivacyRules.cs
View file

@ -7,18 +7,19 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1430961007)]
[TLObject(1352683077)]
public class TLPrivacyRules : TLObject
{
public override int Constructor
{
get
{
return 1430961007;
return 1352683077;
}
}
public TLVector<TLAbsPrivacyRule> Rules { get; set; }
public TLVector<TLAbsChat> Chats { get; set; }
public TLVector<TLAbsUser> Users { get; set; }
@ -30,6 +31,7 @@ namespace TeleSharp.TL.Account
public override void DeserializeBody(BinaryReader br)
{
Rules = (TLVector<TLAbsPrivacyRule>)ObjectUtils.DeserializeVector<TLAbsPrivacyRule>(br);
Chats = (TLVector<TLAbsChat>)ObjectUtils.DeserializeVector<TLAbsChat>(br);
Users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
}
@ -38,6 +40,7 @@ namespace TeleSharp.TL.Account
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Rules, bw);
ObjectUtils.SerializeObject(Chats, bw);
ObjectUtils.SerializeObject(Users, bw);
}

60
src/TeleSharp.TL/TL/Account/TLRequestAcceptAuthorization.cs Normal file
View file

@ -0,0 +1,60 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-419267436)]
public class TLRequestAcceptAuthorization : TLMethod
{
public override int Constructor
{
get
{
return -419267436;
}
}
public int BotId { get; set; }
public string Scope { get; set; }
public string PublicKey { get; set; }
public TLVector<TLSecureValueHash> ValueHashes { get; set; }
public TLSecureCredentialsEncrypted Credentials { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
BotId = br.ReadInt32();
Scope = StringUtil.Deserialize(br);
PublicKey = StringUtil.Deserialize(br);
ValueHashes = (TLVector<TLSecureValueHash>)ObjectUtils.DeserializeVector<TLSecureValueHash>(br);
Credentials = (TLSecureCredentialsEncrypted)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(BotId);
StringUtil.Serialize(Scope, bw);
StringUtil.Serialize(PublicKey, bw);
ObjectUtils.SerializeObject(ValueHashes, bw);
ObjectUtils.SerializeObject(Credentials, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLRequestCancelPasswordEmail.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1043606090)]
public class TLRequestCancelPasswordEmail : TLMethod
{
public override int Constructor
{
get
{
return -1043606090;
}
}
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

48
src/TeleSharp.TL/TL/Account/TLRequestConfirmPasswordEmail.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1881204448)]
public class TLRequestConfirmPasswordEmail : TLMethod
{
public override int Constructor
{
get
{
return -1881204448;
}
}
public string Code { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Code = StringUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
StringUtil.Serialize(Code, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

70
src/TeleSharp.TL/TL/Account/TLRequestCreateTheme.cs Normal file
View file

@ -0,0 +1,70 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-2077048289)]
public class TLRequestCreateTheme : TLMethod
{
public override int Constructor
{
get
{
return -2077048289;
}
}
public int Flags { get; set; }
public string Slug { get; set; }
public string Title { get; set; }
public TLAbsInputDocument Document { get; set; }
public TLInputThemeSettings Settings { get; set; }
public TLTheme Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
Slug = StringUtil.Deserialize(br);
Title = StringUtil.Deserialize(br);
if ((Flags & 4) != 0)
Document = (TLAbsInputDocument)ObjectUtils.DeserializeObject(br);
else
Document = null;
if ((Flags & 8) != 0)
Settings = (TLInputThemeSettings)ObjectUtils.DeserializeObject(br);
else
Settings = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
StringUtil.Serialize(Slug, bw);
StringUtil.Serialize(Title, bw);
if ((Flags & 4) != 0)
ObjectUtils.SerializeObject(Document, bw);
if ((Flags & 8) != 0)
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLTheme)ObjectUtils.DeserializeObject(br);
}
}
}

17
src/TeleSharp.TL/TL/Auth/TLRequestSendInvites.cs → src/TeleSharp.TL/TL/Account/TLRequestDeleteSecureValue.cs
View file

@ -5,21 +5,20 @@ using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
namespace TeleSharp.TL.Account
{
[TLObject(1998331287)]
public class TLRequestSendInvites : TLMethod
[TLObject(-1199522741)]
public class TLRequestDeleteSecureValue : TLMethod
{
public override int Constructor
{
get
{
return 1998331287;
return -1199522741;
}
}
public TLVector<string> PhoneNumbers { get; set; }
public string Message { get; set; }
public TLVector<TLAbsSecureValueType> Types { get; set; }
public bool Response { get; set; }
@ -30,16 +29,14 @@ namespace TeleSharp.TL.Auth
public override void DeserializeBody(BinaryReader br)
{
PhoneNumbers = (TLVector<string>)ObjectUtils.DeserializeVector<string>(br);
Message = StringUtil.Deserialize(br);
Types = (TLVector<TLAbsSecureValueType>)ObjectUtils.DeserializeVector<TLAbsSecureValueType>(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(PhoneNumbers, bw);
StringUtil.Serialize(Message, bw);
ObjectUtils.SerializeObject(Types, bw);
}
public override void DeserializeResponse(BinaryReader br)

51
src/TeleSharp.TL/TL/Account/TLRequestFinishTakeoutSession.cs Normal file
View file

@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(489050862)]
public class TLRequestFinishTakeoutSession : TLMethod
{
public override int Constructor
{
get
{
return 489050862;
}
}
public int Flags { get; set; }
public bool Success { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
Success = (Flags & 1) != 0;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLRequestGetAllSecureValues.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1299661699)]
public class TLRequestGetAllSecureValues : TLMethod
{
public override int Constructor
{
get
{
return -1299661699;
}
}
public TLVector<TLSecureValue> Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLVector<TLSecureValue>)ObjectUtils.DeserializeVector<TLSecureValue>(br);
}
}
}

54
src/TeleSharp.TL/TL/Account/TLRequestGetAuthorizationForm.cs Normal file
View file

@ -0,0 +1,54 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1200903967)]
public class TLRequestGetAuthorizationForm : TLMethod
{
public override int Constructor
{
get
{
return -1200903967;
}
}
public int BotId { get; set; }
public string Scope { get; set; }
public string PublicKey { get; set; }
public Account.TLAuthorizationForm Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
BotId = br.ReadInt32();
Scope = StringUtil.Deserialize(br);
PublicKey = StringUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(BotId);
StringUtil.Serialize(Scope, bw);
StringUtil.Serialize(PublicKey, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Account.TLAuthorizationForm)ObjectUtils.DeserializeObject(br);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLRequestGetAutoDownloadSettings.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1457130303)]
public class TLRequestGetAutoDownloadSettings : TLMethod
{
public override int Constructor
{
get
{
return 1457130303;
}
}
public Account.TLAutoDownloadSettings Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Account.TLAutoDownloadSettings)ObjectUtils.DeserializeObject(br);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLRequestGetContactSignUpNotification.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1626880216)]
public class TLRequestGetContactSignUpNotification : TLMethod
{
public override int Constructor
{
get
{
return -1626880216;
}
}
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLRequestGetContentSettings.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1952756306)]
public class TLRequestGetContentSettings : TLMethod
{
public override int Constructor
{
get
{
return -1952756306;
}
}
public Account.TLContentSettings Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Account.TLContentSettings)ObjectUtils.DeserializeObject(br);
}
}
}

48
src/TeleSharp.TL/TL/Account/TLRequestGetMultiWallPapers.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1705865692)]
public class TLRequestGetMultiWallPapers : TLMethod
{
public override int Constructor
{
get
{
return 1705865692;
}
}
public TLVector<TLAbsInputWallPaper> Wallpapers { get; set; }
public TLVector<TLAbsWallPaper> Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Wallpapers = (TLVector<TLAbsInputWallPaper>)ObjectUtils.DeserializeVector<TLAbsInputWallPaper>(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Wallpapers, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLVector<TLAbsWallPaper>)ObjectUtils.DeserializeVector<TLAbsWallPaper>(br);
}
}
}

59
src/TeleSharp.TL/TL/Account/TLRequestGetNotifyExceptions.cs Normal file
View file

@ -0,0 +1,59 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1398240377)]
public class TLRequestGetNotifyExceptions : TLMethod
{
public override int Constructor
{
get
{
return 1398240377;
}
}
public int Flags { get; set; }
public bool CompareSound { get; set; }
public TLAbsInputNotifyPeer Peer { get; set; }
public TLAbsUpdates Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
CompareSound = (Flags & 2) != 0;
if ((Flags & 1) != 0)
Peer = (TLAbsInputNotifyPeer)ObjectUtils.DeserializeObject(br);
else
Peer = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
if ((Flags & 1) != 0)
ObjectUtils.SerializeObject(Peer, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
}
}
}

4
src/TeleSharp.TL/TL/Account/TLRequestGetNotifySettings.cs
View file

@ -19,7 +19,7 @@ namespace TeleSharp.TL.Account
}
public TLAbsInputNotifyPeer Peer { get; set; }
public TLAbsPeerNotifySettings Response { get; set; }
public TLPeerNotifySettings Response { get; set; }
public void ComputeFlags()
@ -41,7 +41,7 @@ namespace TeleSharp.TL.Account
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLAbsPeerNotifySettings)ObjectUtils.DeserializeObject(br);
Response = (TLPeerNotifySettings)ObjectUtils.DeserializeObject(br);
}
}

4
src/TeleSharp.TL/TL/Account/TLRequestGetPassword.cs
View file

@ -18,7 +18,7 @@ namespace TeleSharp.TL.Account
}
}
public Account.TLAbsPassword Response { get; set; }
public Account.TLPassword Response { get; set; }
public void ComputeFlags()
@ -38,7 +38,7 @@ namespace TeleSharp.TL.Account
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Account.TLAbsPassword)ObjectUtils.DeserializeObject(br);
Response = (Account.TLPassword)ObjectUtils.DeserializeObject(br);
}
}

10
src/TeleSharp.TL/TL/Account/TLRequestGetPasswordSettings.cs
View file

@ -7,18 +7,18 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1131605573)]
[TLObject(-1663767815)]
public class TLRequestGetPasswordSettings : TLMethod
{
public override int Constructor
{
get
{
return -1131605573;
return -1663767815;
}
}
public byte[] CurrentPasswordHash { get; set; }
public TLAbsInputCheckPasswordSRP Password { get; set; }
public Account.TLPasswordSettings Response { get; set; }
@ -29,14 +29,14 @@ namespace TeleSharp.TL.Account
public override void DeserializeBody(BinaryReader br)
{
CurrentPasswordHash = BytesUtil.Deserialize(br);
Password = (TLAbsInputCheckPasswordSRP)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BytesUtil.Serialize(CurrentPasswordHash, bw);
ObjectUtils.SerializeObject(Password, bw);
}
public override void DeserializeResponse(BinaryReader br)

48
src/TeleSharp.TL/TL/Account/TLRequestGetSecureValue.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1936088002)]
public class TLRequestGetSecureValue : TLMethod
{
public override int Constructor
{
get
{
return 1936088002;
}
}
public TLVector<TLAbsSecureValueType> Types { get; set; }
public TLVector<TLSecureValue> Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Types = (TLVector<TLAbsSecureValueType>)ObjectUtils.DeserializeVector<TLAbsSecureValueType>(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Types, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLVector<TLSecureValue>)ObjectUtils.DeserializeVector<TLSecureValue>(br);
}
}
}

54
src/TeleSharp.TL/TL/Account/TLRequestGetTheme.cs Normal file
View file

@ -0,0 +1,54 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1919060949)]
public class TLRequestGetTheme : TLMethod
{
public override int Constructor
{
get
{
return -1919060949;
}
}
public string Format { get; set; }
public TLAbsInputTheme Theme { get; set; }
public long DocumentId { get; set; }
public TLTheme Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Format = StringUtil.Deserialize(br);
Theme = (TLAbsInputTheme)ObjectUtils.DeserializeObject(br);
DocumentId = br.ReadInt64();
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
StringUtil.Serialize(Format, bw);
ObjectUtils.SerializeObject(Theme, bw);
bw.Write(DocumentId);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLTheme)ObjectUtils.DeserializeObject(br);
}
}
}

51
src/TeleSharp.TL/TL/Account/TLRequestGetThemes.cs Normal file
View file

@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(676939512)]
public class TLRequestGetThemes : TLMethod
{
public override int Constructor
{
get
{
return 676939512;
}
}
public string Format { get; set; }
public int Hash { get; set; }
public Account.TLAbsThemes Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Format = StringUtil.Deserialize(br);
Hash = br.ReadInt32();
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
StringUtil.Serialize(Format, bw);
bw.Write(Hash);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Account.TLAbsThemes)ObjectUtils.DeserializeObject(br);
}
}
}

10
src/TeleSharp.TL/TL/Account/TLRequestGetTmpPassword.cs
View file

@ -7,18 +7,18 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1250046590)]
[TLObject(1151208273)]
public class TLRequestGetTmpPassword : TLMethod
{
public override int Constructor
{
get
{
return 1250046590;
return 1151208273;
}
}
public byte[] PasswordHash { get; set; }
public TLAbsInputCheckPasswordSRP Password { get; set; }
public int Period { get; set; }
public Account.TLTmpPassword Response { get; set; }
@ -30,7 +30,7 @@ namespace TeleSharp.TL.Account
public override void DeserializeBody(BinaryReader br)
{
PasswordHash = BytesUtil.Deserialize(br);
Password = (TLAbsInputCheckPasswordSRP)ObjectUtils.DeserializeObject(br);
Period = br.ReadInt32();
}
@ -38,7 +38,7 @@ namespace TeleSharp.TL.Account
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BytesUtil.Serialize(PasswordHash, bw);
ObjectUtils.SerializeObject(Password, bw);
bw.Write(Period);
}

48
src/TeleSharp.TL/TL/Account/TLRequestGetWallPaper.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-57811990)]
public class TLRequestGetWallPaper : TLMethod
{
public override int Constructor
{
get
{
return -57811990;
}
}
public TLAbsInputWallPaper Wallpaper { get; set; }
public TLAbsWallPaper Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Wallpaper = (TLAbsInputWallPaper)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Wallpaper, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLAbsWallPaper)ObjectUtils.DeserializeObject(br);
}
}
}

11
src/TeleSharp.TL/TL/Account/TLRequestGetWallPapers.cs
View file

@ -7,18 +7,19 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1068696894)]
[TLObject(-1430579357)]
public class TLRequestGetWallPapers : TLMethod
{
public override int Constructor
{
get
{
return -1068696894;
return -1430579357;
}
}
public TLVector<TLAbsWallPaper> Response { get; set; }
public int Hash { get; set; }
public Account.TLAbsWallPapers Response { get; set; }
public void ComputeFlags()
@ -28,17 +29,19 @@ namespace TeleSharp.TL.Account
public override void DeserializeBody(BinaryReader br)
{
Hash = br.ReadInt32();
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Hash);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLVector<TLAbsWallPaper>)ObjectUtils.DeserializeVector<TLAbsWallPaper>(br);
Response = (Account.TLAbsWallPapers)ObjectUtils.DeserializeObject(br);
}
}

45
src/TeleSharp.TL/TL/Account/TLRequestGetWebAuthorizations.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(405695855)]
public class TLRequestGetWebAuthorizations : TLMethod
{
public override int Constructor
{
get
{
return 405695855;
}
}
public Account.TLWebAuthorizations Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Account.TLWebAuthorizations)ObjectUtils.DeserializeObject(br);
}
}
}

74
src/TeleSharp.TL/TL/Account/TLRequestInitTakeoutSession.cs Normal file
View file

@ -0,0 +1,74 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-262453244)]
public class TLRequestInitTakeoutSession : TLMethod
{
public override int Constructor
{
get
{
return -262453244;
}
}
public int Flags { get; set; }
public bool Contacts { get; set; }
public bool MessageUsers { get; set; }
public bool MessageChats { get; set; }
public bool MessageMegagroups { get; set; }
public bool MessageChannels { get; set; }
public bool Files { get; set; }
public int? FileMaxSize { get; set; }
public Account.TLTakeout Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
Contacts = (Flags & 1) != 0;
MessageUsers = (Flags & 2) != 0;
MessageChats = (Flags & 4) != 0;
MessageMegagroups = (Flags & 8) != 0;
MessageChannels = (Flags & 16) != 0;
Files = (Flags & 32) != 0;
if ((Flags & 32) != 0)
FileMaxSize = br.ReadInt32();
else
FileMaxSize = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
if ((Flags & 32) != 0)
bw.Write(FileMaxSize.Value);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Account.TLTakeout)ObjectUtils.DeserializeObject(br);
}
}
}

67
src/TeleSharp.TL/TL/Account/TLRequestInstallTheme.cs Normal file
View file

@ -0,0 +1,67 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(2061776695)]
public class TLRequestInstallTheme : TLMethod
{
public override int Constructor
{
get
{
return 2061776695;
}
}
public int Flags { get; set; }
public bool Dark { get; set; }
public string Format { get; set; }
public TLAbsInputTheme Theme { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
Dark = (Flags & 1) != 0;
if ((Flags & 2) != 0)
Format = StringUtil.Deserialize(br);
else
Format = null;
if ((Flags & 2) != 0)
Theme = (TLAbsInputTheme)ObjectUtils.DeserializeObject(br);
else
Theme = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
if ((Flags & 2) != 0)
StringUtil.Serialize(Format, bw);
if ((Flags & 2) != 0)
ObjectUtils.SerializeObject(Theme, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

51
src/TeleSharp.TL/TL/Account/TLRequestInstallWallPaper.cs Normal file
View file

@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-18000023)]
public class TLRequestInstallWallPaper : TLMethod
{
public override int Constructor
{
get
{
return -18000023;
}
}
public TLAbsInputWallPaper Wallpaper { get; set; }
public TLWallPaperSettings Settings { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Wallpaper = (TLAbsInputWallPaper)ObjectUtils.DeserializeObject(br);
Settings = (TLWallPaperSettings)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Wallpaper, bw);
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

19
src/TeleSharp.TL/TL/Account/TLRequestRegisterDevice.cs
View file

@ -7,19 +7,24 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1669245048)]
[TLObject(1754754159)]
public class TLRequestRegisterDevice : TLMethod
{
public override int Constructor
{
get
{
return 1669245048;
return 1754754159;
}
}
public int Flags { get; set; }
public bool NoMuted { get; set; }
public int TokenType { get; set; }
public string Token { get; set; }
public bool AppSandbox { get; set; }
public byte[] Secret { get; set; }
public TLVector<int> OtherUids { get; set; }
public bool Response { get; set; }
@ -30,16 +35,26 @@ namespace TeleSharp.TL.Account
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
NoMuted = (Flags & 1) != 0;
TokenType = br.ReadInt32();
Token = StringUtil.Deserialize(br);
AppSandbox = BoolUtil.Deserialize(br);
Secret = BytesUtil.Deserialize(br);
OtherUids = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
bw.Write(TokenType);
StringUtil.Serialize(Token, bw);
BoolUtil.Serialize(AppSandbox, bw);
BytesUtil.Serialize(Secret, bw);
ObjectUtils.SerializeObject(OtherUids, bw);
}
public override void DeserializeResponse(BinaryReader br)

45
src/TeleSharp.TL/TL/Account/TLRequestResendPasswordEmail.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(2055154197)]
public class TLRequestResendPasswordEmail : TLMethod
{
public override int Constructor
{
get
{
return 2055154197;
}
}
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLRequestResetWallPapers.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1153722364)]
public class TLRequestResetWallPapers : TLMethod
{
public override int Constructor
{
get
{
return -1153722364;
}
}
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

48
src/TeleSharp.TL/TL/Account/TLRequestResetWebAuthorization.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(755087855)]
public class TLRequestResetWebAuthorization : TLMethod
{
public override int Constructor
{
get
{
return 755087855;
}
}
public long Hash { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Hash = br.ReadInt64();
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Hash);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLRequestResetWebAuthorizations.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1747789204)]
public class TLRequestResetWebAuthorizations : TLMethod
{
public override int Constructor
{
get
{
return 1747789204;
}
}
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

57
src/TeleSharp.TL/TL/Account/TLRequestSaveAutoDownloadSettings.cs Normal file
View file

@ -0,0 +1,57 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1995661875)]
public class TLRequestSaveAutoDownloadSettings : TLMethod
{
public override int Constructor
{
get
{
return 1995661875;
}
}
public int Flags { get; set; }
public bool Low { get; set; }
public bool High { get; set; }
public TLAutoDownloadSettings Settings { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
Low = (Flags & 1) != 0;
High = (Flags & 2) != 0;
Settings = (TLAutoDownloadSettings)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

51
src/TeleSharp.TL/TL/Account/TLRequestSaveSecureValue.cs Normal file
View file

@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1986010339)]
public class TLRequestSaveSecureValue : TLMethod
{
public override int Constructor
{
get
{
return -1986010339;
}
}
public TLInputSecureValue Value { get; set; }
public long SecureSecretId { get; set; }
public TLSecureValue Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Value = (TLInputSecureValue)ObjectUtils.DeserializeObject(br);
SecureSecretId = br.ReadInt64();
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Value, bw);
bw.Write(SecureSecretId);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLSecureValue)ObjectUtils.DeserializeObject(br);
}
}
}

51
src/TeleSharp.TL/TL/Account/TLRequestSaveTheme.cs Normal file
View file

@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-229175188)]
public class TLRequestSaveTheme : TLMethod
{
public override int Constructor
{
get
{
return -229175188;
}
}
public TLAbsInputTheme Theme { get; set; }
public bool Unsave { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Theme = (TLAbsInputTheme)ObjectUtils.DeserializeObject(br);
Unsave = BoolUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Theme, bw);
BoolUtil.Serialize(Unsave, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

54
src/TeleSharp.TL/TL/Account/TLRequestSaveWallPaper.cs Normal file
View file

@ -0,0 +1,54 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1817860919)]
public class TLRequestSaveWallPaper : TLMethod
{
public override int Constructor
{
get
{
return 1817860919;
}
}
public TLAbsInputWallPaper Wallpaper { get; set; }
public bool Unsave { get; set; }
public TLWallPaperSettings Settings { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Wallpaper = (TLAbsInputWallPaper)ObjectUtils.DeserializeObject(br);
Unsave = BoolUtil.Deserialize(br);
Settings = (TLWallPaperSettings)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Wallpaper, bw);
BoolUtil.Serialize(Unsave, bw);
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

25
src/TeleSharp.TL/TL/Account/TLRequestSendChangePhoneCode.cs
View file

@ -7,54 +7,39 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(149257707)]
[TLObject(-2108208411)]
public class TLRequestSendChangePhoneCode : TLMethod
{
public override int Constructor
{
get
{
return 149257707;
return -2108208411;
}
}
public int Flags { get; set; }
public bool AllowFlashcall { get; set; }
public string PhoneNumber { get; set; }
public bool? CurrentNumber { get; set; }
public TLCodeSettings Settings { get; set; }
public Auth.TLSentCode Response { get; set; }
public void ComputeFlags()
{
Flags = 0;
Flags = AllowFlashcall ? (Flags | 1) : (Flags & ~1);
Flags = CurrentNumber != null ? (Flags | 1) : (Flags & ~1);
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
AllowFlashcall = (Flags & 1) != 0;
PhoneNumber = StringUtil.Deserialize(br);
if ((Flags & 1) != 0)
CurrentNumber = BoolUtil.Deserialize(br);
else
CurrentNumber = null;
Settings = (TLCodeSettings)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
StringUtil.Serialize(PhoneNumber, bw);
if ((Flags & 1) != 0)
BoolUtil.Serialize(CurrentNumber.Value, bw);
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)

25
src/TeleSharp.TL/TL/Account/TLRequestSendConfirmPhoneCode.cs
View file

@ -7,54 +7,39 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(353818557)]
[TLObject(457157256)]
public class TLRequestSendConfirmPhoneCode : TLMethod
{
public override int Constructor
{
get
{
return 353818557;
return 457157256;
}
}
public int Flags { get; set; }
public bool AllowFlashcall { get; set; }
public string Hash { get; set; }
public bool? CurrentNumber { get; set; }
public TLCodeSettings Settings { get; set; }
public Auth.TLSentCode Response { get; set; }
public void ComputeFlags()
{
Flags = 0;
Flags = AllowFlashcall ? (Flags | 1) : (Flags & ~1);
Flags = CurrentNumber != null ? (Flags | 1) : (Flags & ~1);
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
AllowFlashcall = (Flags & 1) != 0;
Hash = StringUtil.Deserialize(br);
if ((Flags & 1) != 0)
CurrentNumber = BoolUtil.Deserialize(br);
else
CurrentNumber = null;
Settings = (TLCodeSettings)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
StringUtil.Serialize(Hash, bw);
if ((Flags & 1) != 0)
BoolUtil.Serialize(CurrentNumber.Value, bw);
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)

48
src/TeleSharp.TL/TL/Account/TLRequestSendVerifyEmailCode.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1880182943)]
public class TLRequestSendVerifyEmailCode : TLMethod
{
public override int Constructor
{
get
{
return 1880182943;
}
}
public string Email { get; set; }
public Account.TLSentEmailCode Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Email = StringUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
StringUtil.Serialize(Email, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Account.TLSentEmailCode)ObjectUtils.DeserializeObject(br);
}
}
}

15
src/TeleSharp.TL/TL/Auth/TLRequestCheckPhone.cs → src/TeleSharp.TL/TL/Account/TLRequestSendVerifyPhoneCode.cs
View file

@ -5,21 +5,22 @@ using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
namespace TeleSharp.TL.Account
{
[TLObject(1877286395)]
public class TLRequestCheckPhone : TLMethod
[TLObject(-1516022023)]
public class TLRequestSendVerifyPhoneCode : TLMethod
{
public override int Constructor
{
get
{
return 1877286395;
return -1516022023;
}
}
public string PhoneNumber { get; set; }
public Auth.TLCheckedPhone Response { get; set; }
public TLCodeSettings Settings { get; set; }
public Auth.TLSentCode Response { get; set; }
public void ComputeFlags()
@ -30,6 +31,7 @@ namespace TeleSharp.TL.Auth
public override void DeserializeBody(BinaryReader br)
{
PhoneNumber = StringUtil.Deserialize(br);
Settings = (TLCodeSettings)ObjectUtils.DeserializeObject(br);
}
@ -37,11 +39,12 @@ namespace TeleSharp.TL.Auth
{
bw.Write(Constructor);
StringUtil.Serialize(PhoneNumber, bw);
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Auth.TLCheckedPhone)ObjectUtils.DeserializeObject(br);
Response = (Auth.TLSentCode)ObjectUtils.DeserializeObject(br);
}
}

48
src/TeleSharp.TL/TL/Account/TLRequestSetContactSignUpNotification.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-806076575)]
public class TLRequestSetContactSignUpNotification : TLMethod
{
public override int Constructor
{
get
{
return -806076575;
}
}
public bool Silent { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Silent = BoolUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BoolUtil.Serialize(Silent, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

51
src/TeleSharp.TL/TL/Account/TLRequestSetContentSettings.cs Normal file
View file

@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-1250643605)]
public class TLRequestSetContentSettings : TLMethod
{
public override int Constructor
{
get
{
return -1250643605;
}
}
public int Flags { get; set; }
public bool SensitiveEnabled { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
SensitiveEnabled = (Flags & 1) != 0;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

7
src/TeleSharp.TL/TL/Account/TLRequestUnregisterDevice.cs
View file

@ -7,19 +7,20 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1707432768)]
[TLObject(813089983)]
public class TLRequestUnregisterDevice : TLMethod
{
public override int Constructor
{
get
{
return 1707432768;
return 813089983;
}
}
public int TokenType { get; set; }
public string Token { get; set; }
public TLVector<int> OtherUids { get; set; }
public bool Response { get; set; }
@ -32,6 +33,7 @@ namespace TeleSharp.TL.Account
{
TokenType = br.ReadInt32();
Token = StringUtil.Deserialize(br);
OtherUids = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
}
@ -40,6 +42,7 @@ namespace TeleSharp.TL.Account
bw.Write(Constructor);
bw.Write(TokenType);
StringUtil.Serialize(Token, bw);
ObjectUtils.SerializeObject(OtherUids, bw);
}
public override void DeserializeResponse(BinaryReader br)

10
src/TeleSharp.TL/TL/Account/TLRequestUpdatePasswordSettings.cs
View file

@ -7,18 +7,18 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-92517498)]
[TLObject(-1516564433)]
public class TLRequestUpdatePasswordSettings : TLMethod
{
public override int Constructor
{
get
{
return -92517498;
return -1516564433;
}
}
public byte[] CurrentPasswordHash { get; set; }
public TLAbsInputCheckPasswordSRP Password { get; set; }
public Account.TLPasswordInputSettings NewSettings { get; set; }
public bool Response { get; set; }
@ -30,7 +30,7 @@ namespace TeleSharp.TL.Account
public override void DeserializeBody(BinaryReader br)
{
CurrentPasswordHash = BytesUtil.Deserialize(br);
Password = (TLAbsInputCheckPasswordSRP)ObjectUtils.DeserializeObject(br);
NewSettings = (Account.TLPasswordInputSettings)ObjectUtils.DeserializeObject(br);
}
@ -38,7 +38,7 @@ namespace TeleSharp.TL.Account
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BytesUtil.Serialize(CurrentPasswordHash, bw);
ObjectUtils.SerializeObject(Password, bw);
ObjectUtils.SerializeObject(NewSettings, bw);
}

5
src/TeleSharp.TL/TL/Account/TLRequestUpdateProfile.cs
View file

@ -27,10 +27,6 @@ namespace TeleSharp.TL.Account
public void ComputeFlags()
{
Flags = 0;
Flags = FirstName != null ? (Flags | 1) : (Flags & ~1);
Flags = LastName != null ? (Flags | 2) : (Flags & ~2);
Flags = About != null ? (Flags | 4) : (Flags & ~4);
}
@ -58,7 +54,6 @@ namespace TeleSharp.TL.Account
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
if ((Flags & 1) != 0)
StringUtil.Serialize(FirstName, bw);

86
src/TeleSharp.TL/TL/Account/TLRequestUpdateTheme.cs Normal file
View file

@ -0,0 +1,86 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1555261397)]
public class TLRequestUpdateTheme : TLMethod
{
public override int Constructor
{
get
{
return 1555261397;
}
}
public int Flags { get; set; }
public string Format { get; set; }
public TLAbsInputTheme Theme { get; set; }
public string Slug { get; set; }
public string Title { get; set; }
public TLAbsInputDocument Document { get; set; }
public TLInputThemeSettings Settings { get; set; }
public TLTheme Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
Format = StringUtil.Deserialize(br);
Theme = (TLAbsInputTheme)ObjectUtils.DeserializeObject(br);
if ((Flags & 1) != 0)
Slug = StringUtil.Deserialize(br);
else
Slug = null;
if ((Flags & 2) != 0)
Title = StringUtil.Deserialize(br);
else
Title = null;
if ((Flags & 4) != 0)
Document = (TLAbsInputDocument)ObjectUtils.DeserializeObject(br);
else
Document = null;
if ((Flags & 8) != 0)
Settings = (TLInputThemeSettings)ObjectUtils.DeserializeObject(br);
else
Settings = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
StringUtil.Serialize(Format, bw);
ObjectUtils.SerializeObject(Theme, bw);
if ((Flags & 1) != 0)
StringUtil.Serialize(Slug, bw);
if ((Flags & 2) != 0)
StringUtil.Serialize(Title, bw);
if ((Flags & 4) != 0)
ObjectUtils.SerializeObject(Document, bw);
if ((Flags & 8) != 0)
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLTheme)ObjectUtils.DeserializeObject(br);
}
}
}

39
src/TeleSharp.TL/TL/TLInputMediaUploadedThumbDocument.cs → src/TeleSharp.TL/TL/Account/TLRequestUploadTheme.cs
View file

@ -5,32 +5,29 @@ using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL
namespace TeleSharp.TL.Account
{
[TLObject(1356369070)]
public class TLInputMediaUploadedThumbDocument : TLAbsInputMedia
[TLObject(473805619)]
public class TLRequestUploadTheme : TLMethod
{
public override int Constructor
{
get
{
return 1356369070;
return 473805619;
}
}
public int Flags { get; set; }
public TLAbsInputFile File { get; set; }
public TLAbsInputFile Thumb { get; set; }
public string FileName { get; set; }
public string MimeType { get; set; }
public TLVector<TLAbsDocumentAttribute> Attributes { get; set; }
public string Caption { get; set; }
public TLVector<TLAbsInputDocument> Stickers { get; set; }
public TLAbsDocument Response { get; set; }
public void ComputeFlags()
{
Flags = 0;
Flags = Stickers != null ? (Flags | 1) : (Flags & ~1);
}
@ -38,30 +35,30 @@ namespace TeleSharp.TL
{
Flags = br.ReadInt32();
File = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
Thumb = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
MimeType = StringUtil.Deserialize(br);
Attributes = (TLVector<TLAbsDocumentAttribute>)ObjectUtils.DeserializeVector<TLAbsDocumentAttribute>(br);
Caption = StringUtil.Deserialize(br);
if ((Flags & 1) != 0)
Stickers = (TLVector<TLAbsInputDocument>)ObjectUtils.DeserializeVector<TLAbsInputDocument>(br);
Thumb = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
else
Stickers = null;
Thumb = null;
FileName = StringUtil.Deserialize(br);
MimeType = StringUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
ObjectUtils.SerializeObject(File, bw);
ObjectUtils.SerializeObject(Thumb, bw);
StringUtil.Serialize(MimeType, bw);
ObjectUtils.SerializeObject(Attributes, bw);
StringUtil.Serialize(Caption, bw);
if ((Flags & 1) != 0)
ObjectUtils.SerializeObject(Stickers, bw);
ObjectUtils.SerializeObject(Thumb, bw);
StringUtil.Serialize(FileName, bw);
StringUtil.Serialize(MimeType, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLAbsDocument)ObjectUtils.DeserializeObject(br);
}
}

54
src/TeleSharp.TL/TL/Account/TLRequestUploadWallPaper.cs Normal file
View file

@ -0,0 +1,54 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-578472351)]
public class TLRequestUploadWallPaper : TLMethod
{
public override int Constructor
{
get
{
return -578472351;
}
}
public TLAbsInputFile File { get; set; }
public string MimeType { get; set; }
public TLWallPaperSettings Settings { get; set; }
public TLAbsWallPaper Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
File = (TLAbsInputFile)ObjectUtils.DeserializeObject(br);
MimeType = StringUtil.Deserialize(br);
Settings = (TLWallPaperSettings)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(File, bw);
StringUtil.Serialize(MimeType, bw);
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLAbsWallPaper)ObjectUtils.DeserializeObject(br);
}
}
}

51
src/TeleSharp.TL/TL/Account/TLRequestVerifyEmail.cs Normal file
View file

@ -0,0 +1,51 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-323339813)]
public class TLRequestVerifyEmail : TLMethod
{
public override int Constructor
{
get
{
return -323339813;
}
}
public string Email { get; set; }
public string Code { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Email = StringUtil.Deserialize(br);
Code = StringUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
StringUtil.Serialize(Email, bw);
StringUtil.Serialize(Code, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

54
src/TeleSharp.TL/TL/Account/TLRequestVerifyPhone.cs Normal file
View file

@ -0,0 +1,54 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1305716726)]
public class TLRequestVerifyPhone : TLMethod
{
public override int Constructor
{
get
{
return 1305716726;
}
}
public string PhoneNumber { get; set; }
public string PhoneCodeHash { get; set; }
public string PhoneCode { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
PhoneNumber = StringUtil.Deserialize(br);
PhoneCodeHash = StringUtil.Deserialize(br);
PhoneCode = StringUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
StringUtil.Serialize(PhoneNumber, bw);
StringUtil.Serialize(PhoneCodeHash, bw);
StringUtil.Serialize(PhoneCode, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLSentEmailCode.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-2128640689)]
public class TLSentEmailCode : TLObject
{
public override int Constructor
{
get
{
return -2128640689;
}
}
public string EmailPattern { get; set; }
public int Length { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
EmailPattern = StringUtil.Deserialize(br);
Length = br.ReadInt32();
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
StringUtil.Serialize(EmailPattern, bw);
bw.Write(Length);
}
}
}

42
src/TeleSharp.TL/TL/Account/TLTakeout.cs Normal file
View file

@ -0,0 +1,42 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1304052993)]
public class TLTakeout : TLObject
{
public override int Constructor
{
get
{
return 1304052993;
}
}
public long Id { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Id = br.ReadInt64();
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Id);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLThemes.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(2137482273)]
public class TLThemes : TLAbsThemes
{
public override int Constructor
{
get
{
return 2137482273;
}
}
public int Hash { get; set; }
public TLVector<TLTheme> Themes { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Hash = br.ReadInt32();
Themes = (TLVector<TLTheme>)ObjectUtils.DeserializeVector<TLTheme>(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Hash);
ObjectUtils.SerializeObject(Themes, bw);
}
}
}

39
src/TeleSharp.TL/TL/Account/TLThemesNotModified.cs Normal file
View file

@ -0,0 +1,39 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-199313886)]
public class TLThemesNotModified : TLAbsThemes
{
public override int Constructor
{
get
{
return -199313886;
}
}
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLWallPapers.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(1881892265)]
public class TLWallPapers : TLAbsWallPapers
{
public override int Constructor
{
get
{
return 1881892265;
}
}
public int Hash { get; set; }
public TLVector<TLAbsWallPaper> Wallpapers { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Hash = br.ReadInt32();
Wallpapers = (TLVector<TLAbsWallPaper>)ObjectUtils.DeserializeVector<TLAbsWallPaper>(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Hash);
ObjectUtils.SerializeObject(Wallpapers, bw);
}
}
}

39
src/TeleSharp.TL/TL/Account/TLWallPapersNotModified.cs Normal file
View file

@ -0,0 +1,39 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(471437699)]
public class TLWallPapersNotModified : TLAbsWallPapers
{
public override int Constructor
{
get
{
return 471437699;
}
}
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
}
}

45
src/TeleSharp.TL/TL/Account/TLWebAuthorizations.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Account
{
[TLObject(-313079300)]
public class TLWebAuthorizations : TLObject
{
public override int Constructor
{
get
{
return -313079300;
}
}
public TLVector<TLWebAuthorization> Authorizations { get; set; }
public TLVector<TLAbsUser> Users { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Authorizations = (TLVector<TLWebAuthorization>)ObjectUtils.DeserializeVector<TLWebAuthorization>(br);
Users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Authorizations, bw);
ObjectUtils.SerializeObject(Users, bw);
}
}
}

13
src/TeleSharp.TL/TL/Auth/TLAbsAuthorization.cs Normal file
View file

@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
public abstract class TLAbsAuthorization : TLObject
{
}
}

13
src/TeleSharp.TL/TL/Auth/TLAbsLoginToken.cs Normal file
View file

@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
public abstract class TLAbsLoginToken : TLObject
{
}
}

5
src/TeleSharp.TL/TL/Auth/TLAuthorization.cs
View file

@ -8,7 +8,7 @@ using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(-855308010)]
public class TLAuthorization : TLObject
public class TLAuthorization : TLAbsAuthorization
{
public override int Constructor
{
@ -25,8 +25,6 @@ namespace TeleSharp.TL.Auth
public void ComputeFlags()
{
Flags = 0;
Flags = TmpSessions != null ? (Flags | 1) : (Flags & ~1);
}
@ -45,7 +43,6 @@ namespace TeleSharp.TL.Auth
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
if ((Flags & 1) != 0)
bw.Write(TmpSessions.Value);

50
src/TeleSharp.TL/TL/Auth/TLAuthorizationSignUpRequired.cs Normal file
View file

@ -0,0 +1,50 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(1148485274)]
public class TLAuthorizationSignUpRequired : TLAbsAuthorization
{
public override int Constructor
{
get
{
return 1148485274;
}
}
public int Flags { get; set; }
public Help.TLTermsOfService TermsOfService { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
if ((Flags & 1) != 0)
TermsOfService = (Help.TLTermsOfService)ObjectUtils.DeserializeObject(br);
else
TermsOfService = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
if ((Flags & 1) != 0)
ObjectUtils.SerializeObject(TermsOfService, bw);
}
}
}

45
src/TeleSharp.TL/TL/Auth/TLLoginToken.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(1654593920)]
public class TLLoginToken : TLAbsLoginToken
{
public override int Constructor
{
get
{
return 1654593920;
}
}
public int Expires { get; set; }
public byte[] Token { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Expires = br.ReadInt32();
Token = BytesUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Expires);
BytesUtil.Serialize(Token, bw);
}
}
}

45
src/TeleSharp.TL/TL/Auth/TLLoginTokenMigrateTo.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(110008598)]
public class TLLoginTokenMigrateTo : TLAbsLoginToken
{
public override int Constructor
{
get
{
return 110008598;
}
}
public int DcId { get; set; }
public byte[] Token { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
DcId = br.ReadInt32();
Token = BytesUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(DcId);
BytesUtil.Serialize(Token, bw);
}
}
}

12
src/TeleSharp.TL/TL/Auth/TLCheckedPhone.cs → src/TeleSharp.TL/TL/Auth/TLLoginTokenSuccess.cs
View file

@ -7,18 +7,18 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(-2128698738)]
public class TLCheckedPhone : TLObject
[TLObject(957176926)]
public class TLLoginTokenSuccess : TLAbsLoginToken
{
public override int Constructor
{
get
{
return -2128698738;
return 957176926;
}
}
public bool PhoneRegistered { get; set; }
public Auth.TLAbsAuthorization Authorization { get; set; }
public void ComputeFlags()
@ -28,14 +28,14 @@ namespace TeleSharp.TL.Auth
public override void DeserializeBody(BinaryReader br)
{
PhoneRegistered = BoolUtil.Deserialize(br);
Authorization = (Auth.TLAbsAuthorization)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BoolUtil.Serialize(PhoneRegistered, bw);
ObjectUtils.SerializeObject(Authorization, bw);
}
}

48
src/TeleSharp.TL/TL/Auth/TLRequestAcceptLoginToken.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(-392909491)]
public class TLRequestAcceptLoginToken : TLMethod
{
public override int Constructor
{
get
{
return -392909491;
}
}
public byte[] Token { get; set; }
public TLAuthorization Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Token = BytesUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BytesUtil.Serialize(Token, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLAuthorization)ObjectUtils.DeserializeObject(br);
}
}
}

14
src/TeleSharp.TL/TL/Auth/TLRequestCheckPassword.cs
View file

@ -7,19 +7,19 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(174260510)]
[TLObject(-779399914)]
public class TLRequestCheckPassword : TLMethod
{
public override int Constructor
{
get
{
return 174260510;
return -779399914;
}
}
public byte[] PasswordHash { get; set; }
public Auth.TLAuthorization Response { get; set; }
public TLAbsInputCheckPasswordSRP Password { get; set; }
public Auth.TLAbsAuthorization Response { get; set; }
public void ComputeFlags()
@ -29,19 +29,19 @@ namespace TeleSharp.TL.Auth
public override void DeserializeBody(BinaryReader br)
{
PasswordHash = BytesUtil.Deserialize(br);
Password = (TLAbsInputCheckPasswordSRP)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BytesUtil.Serialize(PasswordHash, bw);
ObjectUtils.SerializeObject(Password, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
Response = (Auth.TLAbsAuthorization)ObjectUtils.DeserializeObject(br);
}
}

54
src/TeleSharp.TL/TL/Auth/TLRequestExportLoginToken.cs Normal file
View file

@ -0,0 +1,54 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(-1313598185)]
public class TLRequestExportLoginToken : TLMethod
{
public override int Constructor
{
get
{
return -1313598185;
}
}
public int ApiId { get; set; }
public string ApiHash { get; set; }
public TLVector<int> ExceptIds { get; set; }
public Auth.TLAbsLoginToken Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
ApiId = br.ReadInt32();
ApiHash = StringUtil.Deserialize(br);
ExceptIds = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(ApiId);
StringUtil.Serialize(ApiHash, bw);
ObjectUtils.SerializeObject(ExceptIds, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Auth.TLAbsLoginToken)ObjectUtils.DeserializeObject(br);
}
}
}

4
src/TeleSharp.TL/TL/Auth/TLRequestImportAuthorization.cs
View file

@ -20,7 +20,7 @@ namespace TeleSharp.TL.Auth
public int Id { get; set; }
public byte[] Bytes { get; set; }
public Auth.TLAuthorization Response { get; set; }
public Auth.TLAbsAuthorization Response { get; set; }
public void ComputeFlags()
@ -44,7 +44,7 @@ namespace TeleSharp.TL.Auth
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
Response = (Auth.TLAbsAuthorization)ObjectUtils.DeserializeObject(br);
}
}

6
src/TeleSharp.TL/TL/Auth/TLRequestImportBotAuthorization.cs
View file

@ -22,12 +22,11 @@ namespace TeleSharp.TL.Auth
public int ApiId { get; set; }
public string ApiHash { get; set; }
public string BotAuthToken { get; set; }
public Auth.TLAuthorization Response { get; set; }
public Auth.TLAbsAuthorization Response { get; set; }
public void ComputeFlags()
{
Flags = 0;
}
@ -43,7 +42,6 @@ namespace TeleSharp.TL.Auth
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
bw.Write(ApiId);
StringUtil.Serialize(ApiHash, bw);
@ -52,7 +50,7 @@ namespace TeleSharp.TL.Auth
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
Response = (Auth.TLAbsAuthorization)ObjectUtils.DeserializeObject(br);
}
}

48
src/TeleSharp.TL/TL/Auth/TLRequestImportLoginToken.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(-1783866140)]
public class TLRequestImportLoginToken : TLMethod
{
public override int Constructor
{
get
{
return -1783866140;
}
}
public byte[] Token { get; set; }
public Auth.TLAbsLoginToken Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Token = BytesUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
BytesUtil.Serialize(Token, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Auth.TLAbsLoginToken)ObjectUtils.DeserializeObject(br);
}
}
}

4
src/TeleSharp.TL/TL/Auth/TLRequestRecoverPassword.cs
View file

@ -19,7 +19,7 @@ namespace TeleSharp.TL.Auth
}
public string Code { get; set; }
public Auth.TLAuthorization Response { get; set; }
public Auth.TLAbsAuthorization Response { get; set; }
public void ComputeFlags()
@ -41,7 +41,7 @@ namespace TeleSharp.TL.Auth
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
Response = (Auth.TLAbsAuthorization)ObjectUtils.DeserializeObject(br);
}
}

25
src/TeleSharp.TL/TL/Auth/TLRequestSendCode.cs
View file

@ -7,60 +7,45 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(-2035355412)]
[TLObject(-1502141361)]
public class TLRequestSendCode : TLMethod
{
public override int Constructor
{
get
{
return -2035355412;
return -1502141361;
}
}
public int Flags { get; set; }
public bool AllowFlashcall { get; set; }
public string PhoneNumber { get; set; }
public bool? CurrentNumber { get; set; }
public int ApiId { get; set; }
public string ApiHash { get; set; }
public TLCodeSettings Settings { get; set; }
public Auth.TLSentCode Response { get; set; }
public void ComputeFlags()
{
Flags = 0;
Flags = AllowFlashcall ? (Flags | 1) : (Flags & ~1);
Flags = CurrentNumber != null ? (Flags | 1) : (Flags & ~1);
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
AllowFlashcall = (Flags & 1) != 0;
PhoneNumber = StringUtil.Deserialize(br);
if ((Flags & 1) != 0)
CurrentNumber = BoolUtil.Deserialize(br);
else
CurrentNumber = null;
ApiId = br.ReadInt32();
ApiHash = StringUtil.Deserialize(br);
Settings = (TLCodeSettings)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
StringUtil.Serialize(PhoneNumber, bw);
if ((Flags & 1) != 0)
BoolUtil.Serialize(CurrentNumber.Value, bw);
bw.Write(ApiId);
StringUtil.Serialize(ApiHash, bw);
ObjectUtils.SerializeObject(Settings, bw);
}
public override void DeserializeResponse(BinaryReader br)

4
src/TeleSharp.TL/TL/Auth/TLRequestSignIn.cs
View file

@ -21,7 +21,7 @@ namespace TeleSharp.TL.Auth
public string PhoneNumber { get; set; }
public string PhoneCodeHash { get; set; }
public string PhoneCode { get; set; }
public Auth.TLAuthorization Response { get; set; }
public Auth.TLAbsAuthorization Response { get; set; }
public void ComputeFlags()
@ -47,7 +47,7 @@ namespace TeleSharp.TL.Auth
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
Response = (Auth.TLAbsAuthorization)ObjectUtils.DeserializeObject(br);
}
}

7
src/TeleSharp.TL/TL/Auth/TLRequestSignUp.cs
View file

@ -7,20 +7,19 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Auth
{
[TLObject(453408308)]
[TLObject(-2131827673)]
public class TLRequestSignUp : TLMethod
{
public override int Constructor
{
get
{
return 453408308;
return -2131827673;
}
}
public string PhoneNumber { get; set; }
public string PhoneCodeHash { get; set; }
public string PhoneCode { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public Auth.TLAuthorization Response { get; set; }
@ -35,7 +34,6 @@ namespace TeleSharp.TL.Auth
{
PhoneNumber = StringUtil.Deserialize(br);
PhoneCodeHash = StringUtil.Deserialize(br);
PhoneCode = StringUtil.Deserialize(br);
FirstName = StringUtil.Deserialize(br);
LastName = StringUtil.Deserialize(br);
@ -46,7 +44,6 @@ namespace TeleSharp.TL.Auth
bw.Write(Constructor);
StringUtil.Serialize(PhoneNumber, bw);
StringUtil.Serialize(PhoneCodeHash, bw);
StringUtil.Serialize(PhoneCode, bw);
StringUtil.Serialize(FirstName, bw);
StringUtil.Serialize(LastName, bw);

8
src/TeleSharp.TL/TL/Auth/TLSentCode.cs
View file

@ -19,7 +19,6 @@ namespace TeleSharp.TL.Auth
}
public int Flags { get; set; }
public bool PhoneRegistered { get; set; }
public Auth.TLAbsSentCodeType Type { get; set; }
public string PhoneCodeHash { get; set; }
public Auth.TLAbsCodeType NextType { get; set; }
@ -28,17 +27,12 @@ namespace TeleSharp.TL.Auth
public void ComputeFlags()
{
Flags = 0;
Flags = PhoneRegistered ? (Flags | 1) : (Flags & ~1);
Flags = NextType != null ? (Flags | 2) : (Flags & ~2);
Flags = Timeout != null ? (Flags | 4) : (Flags & ~4);
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
PhoneRegistered = (Flags & 1) != 0;
Type = (Auth.TLAbsSentCodeType)ObjectUtils.DeserializeObject(br);
PhoneCodeHash = StringUtil.Deserialize(br);
if ((Flags & 2) != 0)
@ -57,9 +51,7 @@ namespace TeleSharp.TL.Auth
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
ObjectUtils.SerializeObject(Type, bw);
StringUtil.Serialize(PhoneCodeHash, bw);
if ((Flags & 2) != 0)

13
src/TeleSharp.TL/TL/Channels/TLAbsChannelParticipants.cs Normal file
View file

@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
public abstract class TLAbsChannelParticipants : TLObject
{
}
}

48
src/TeleSharp.TL/TL/Channels/TLAdminLogResults.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-309659827)]
public class TLAdminLogResults : TLObject
{
public override int Constructor
{
get
{
return -309659827;
}
}
public TLVector<TLChannelAdminLogEvent> Events { get; set; }
public TLVector<TLAbsChat> Chats { get; set; }
public TLVector<TLAbsUser> Users { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Events = (TLVector<TLChannelAdminLogEvent>)ObjectUtils.DeserializeVector<TLChannelAdminLogEvent>(br);
Chats = (TLVector<TLAbsChat>)ObjectUtils.DeserializeVector<TLAbsChat>(br);
Users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Events, bw);
ObjectUtils.SerializeObject(Chats, bw);
ObjectUtils.SerializeObject(Users, bw);
}
}
}

2
src/TeleSharp.TL/TL/Channels/TLChannelParticipants.cs
View file

@ -8,7 +8,7 @@ using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-177282392)]
public class TLChannelParticipants : TLObject
public class TLChannelParticipants : TLAbsChannelParticipants
{
public override int Constructor
{

39
src/TeleSharp.TL/TL/Channels/TLChannelParticipantsNotModified.cs Normal file
View file

@ -0,0 +1,39 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-266911767)]
public class TLChannelParticipantsNotModified : TLAbsChannelParticipants
{
public override int Constructor
{
get
{
return -266911767;
}
}
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
}
}

24
src/TeleSharp.TL/TL/Channels/TLRequestCreateChannel.cs
View file

@ -7,14 +7,14 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-192332417)]
[TLObject(1029681423)]
public class TLRequestCreateChannel : TLMethod
{
public override int Constructor
{
get
{
return -192332417;
return 1029681423;
}
}
@ -23,14 +23,13 @@ namespace TeleSharp.TL.Channels
public bool Megagroup { get; set; }
public string Title { get; set; }
public string About { get; set; }
public TLAbsInputGeoPoint GeoPoint { get; set; }
public string Address { get; set; }
public TLAbsUpdates Response { get; set; }
public void ComputeFlags()
{
Flags = 0;
Flags = Broadcast ? (Flags | 1) : (Flags & ~1);
Flags = Megagroup ? (Flags | 2) : (Flags & ~2);
}
@ -41,18 +40,31 @@ namespace TeleSharp.TL.Channels
Megagroup = (Flags & 2) != 0;
Title = StringUtil.Deserialize(br);
About = StringUtil.Deserialize(br);
if ((Flags & 4) != 0)
GeoPoint = (TLAbsInputGeoPoint)ObjectUtils.DeserializeObject(br);
else
GeoPoint = null;
if ((Flags & 4) != 0)
Address = StringUtil.Deserialize(br);
else
Address = null;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ComputeFlags();
bw.Write(Flags);
StringUtil.Serialize(Title, bw);
StringUtil.Serialize(About, bw);
if ((Flags & 4) != 0)
ObjectUtils.SerializeObject(GeoPoint, bw);
if ((Flags & 4) != 0)
StringUtil.Serialize(Address, bw);
}
public override void DeserializeResponse(BinaryReader br)

12
src/TeleSharp.TL/TL/Channels/TLRequestEditAbout.cs → src/TeleSharp.TL/TL/Channels/TLRequestDeleteHistory.cs
View file

@ -7,19 +7,19 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(333610782)]
public class TLRequestEditAbout : TLMethod
[TLObject(-1355375294)]
public class TLRequestDeleteHistory : TLMethod
{
public override int Constructor
{
get
{
return 333610782;
return -1355375294;
}
}
public TLAbsInputChannel Channel { get; set; }
public string About { get; set; }
public int MaxId { get; set; }
public bool Response { get; set; }
@ -31,7 +31,7 @@ namespace TeleSharp.TL.Channels
public override void DeserializeBody(BinaryReader br)
{
Channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
About = StringUtil.Deserialize(br);
MaxId = br.ReadInt32();
}
@ -39,7 +39,7 @@ namespace TeleSharp.TL.Channels
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Channel, bw);
StringUtil.Serialize(About, bw);
bw.Write(MaxId);
}
public override void DeserializeResponse(BinaryReader br)

13
src/TeleSharp.TL/TL/Channels/TLRequestEditAdmin.cs
View file

@ -7,20 +7,21 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-344583728)]
[TLObject(-751007486)]
public class TLRequestEditAdmin : TLMethod
{
public override int Constructor
{
get
{
return -344583728;
return -751007486;
}
}
public TLAbsInputChannel Channel { get; set; }
public TLAbsInputUser UserId { get; set; }
public TLAbsChannelParticipantRole Role { get; set; }
public TLChatAdminRights AdminRights { get; set; }
public string Rank { get; set; }
public TLAbsUpdates Response { get; set; }
@ -33,7 +34,8 @@ namespace TeleSharp.TL.Channels
{
Channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
UserId = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
Role = (TLAbsChannelParticipantRole)ObjectUtils.DeserializeObject(br);
AdminRights = (TLChatAdminRights)ObjectUtils.DeserializeObject(br);
Rank = StringUtil.Deserialize(br);
}
@ -42,7 +44,8 @@ namespace TeleSharp.TL.Channels
bw.Write(Constructor);
ObjectUtils.SerializeObject(Channel, bw);
ObjectUtils.SerializeObject(UserId, bw);
ObjectUtils.SerializeObject(Role, bw);
ObjectUtils.SerializeObject(AdminRights, bw);
StringUtil.Serialize(Rank, bw);
}
public override void DeserializeResponse(BinaryReader br)

12
src/TeleSharp.TL/TL/Channels/TLRequestKickFromChannel.cs → src/TeleSharp.TL/TL/Channels/TLRequestEditBanned.cs
View file

@ -7,20 +7,20 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-1502421484)]
public class TLRequestKickFromChannel : TLMethod
[TLObject(1920559378)]
public class TLRequestEditBanned : TLMethod
{
public override int Constructor
{
get
{
return -1502421484;
return 1920559378;
}
}
public TLAbsInputChannel Channel { get; set; }
public TLAbsInputUser UserId { get; set; }
public bool Kicked { get; set; }
public TLChatBannedRights BannedRights { get; set; }
public TLAbsUpdates Response { get; set; }
@ -33,7 +33,7 @@ namespace TeleSharp.TL.Channels
{
Channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
UserId = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
Kicked = BoolUtil.Deserialize(br);
BannedRights = (TLChatBannedRights)ObjectUtils.DeserializeObject(br);
}
@ -42,7 +42,7 @@ namespace TeleSharp.TL.Channels
bw.Write(Constructor);
ObjectUtils.SerializeObject(Channel, bw);
ObjectUtils.SerializeObject(UserId, bw);
BoolUtil.Serialize(Kicked, bw);
ObjectUtils.SerializeObject(BannedRights, bw);
}
public override void DeserializeResponse(BinaryReader br)

54
src/TeleSharp.TL/TL/Channels/TLRequestEditCreator.cs Normal file
View file

@ -0,0 +1,54 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-1892102881)]
public class TLRequestEditCreator : TLMethod
{
public override int Constructor
{
get
{
return -1892102881;
}
}
public TLAbsInputChannel Channel { get; set; }
public TLAbsInputUser UserId { get; set; }
public TLAbsInputCheckPasswordSRP Password { get; set; }
public TLAbsUpdates Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
UserId = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
Password = (TLAbsInputCheckPasswordSRP)ObjectUtils.DeserializeObject(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Channel, bw);
ObjectUtils.SerializeObject(UserId, bw);
ObjectUtils.SerializeObject(Password, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
}
}
}

54
src/TeleSharp.TL/TL/Channels/TLRequestEditLocation.cs Normal file
View file

@ -0,0 +1,54 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(1491484525)]
public class TLRequestEditLocation : TLMethod
{
public override int Constructor
{
get
{
return 1491484525;
}
}
public TLAbsInputChannel Channel { get; set; }
public TLAbsInputGeoPoint GeoPoint { get; set; }
public string Address { get; set; }
public bool Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
GeoPoint = (TLAbsInputGeoPoint)ObjectUtils.DeserializeObject(br);
Address = StringUtil.Deserialize(br);
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
ObjectUtils.SerializeObject(Channel, bw);
ObjectUtils.SerializeObject(GeoPoint, bw);
StringUtil.Serialize(Address, bw);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = BoolUtil.Deserialize(br);
}
}
}

7
src/TeleSharp.TL/TL/Channels/TLRequestExportMessageLink.cs
View file

@ -7,19 +7,20 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-934882771)]
[TLObject(-826838685)]
public class TLRequestExportMessageLink : TLMethod
{
public override int Constructor
{
get
{
return -934882771;
return -826838685;
}
}
public TLAbsInputChannel Channel { get; set; }
public int Id { get; set; }
public bool Grouped { get; set; }
public TLExportedMessageLink Response { get; set; }
@ -32,6 +33,7 @@ namespace TeleSharp.TL.Channels
{
Channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
Id = br.ReadInt32();
Grouped = BoolUtil.Deserialize(br);
}
@ -40,6 +42,7 @@ namespace TeleSharp.TL.Channels
bw.Write(Constructor);
ObjectUtils.SerializeObject(Channel, bw);
bw.Write(Id);
BoolUtil.Serialize(Grouped, bw);
}
public override void DeserializeResponse(BinaryReader br)

79
src/TeleSharp.TL/TL/Channels/TLRequestGetAdminLog.cs Normal file
View file

@ -0,0 +1,79 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(870184064)]
public class TLRequestGetAdminLog : TLMethod
{
public override int Constructor
{
get
{
return 870184064;
}
}
public int Flags { get; set; }
public TLAbsInputChannel Channel { get; set; }
public string Q { get; set; }
public TLChannelAdminLogEventsFilter EventsFilter { get; set; }
public TLVector<TLAbsInputUser> Admins { get; set; }
public long MaxId { get; set; }
public long MinId { get; set; }
public int Limit { get; set; }
public Channels.TLAdminLogResults Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
Channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
Q = StringUtil.Deserialize(br);
if ((Flags & 1) != 0)
EventsFilter = (TLChannelAdminLogEventsFilter)ObjectUtils.DeserializeObject(br);
else
EventsFilter = null;
if ((Flags & 2) != 0)
Admins = (TLVector<TLAbsInputUser>)ObjectUtils.DeserializeVector<TLAbsInputUser>(br);
else
Admins = null;
MaxId = br.ReadInt64();
MinId = br.ReadInt64();
Limit = br.ReadInt32();
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
ObjectUtils.SerializeObject(Channel, bw);
StringUtil.Serialize(Q, bw);
if ((Flags & 1) != 0)
ObjectUtils.SerializeObject(EventsFilter, bw);
if ((Flags & 2) != 0)
ObjectUtils.SerializeObject(Admins, bw);
bw.Write(MaxId);
bw.Write(MinId);
bw.Write(Limit);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Channels.TLAdminLogResults)ObjectUtils.DeserializeObject(br);
}
}
}

13
src/TeleSharp.TL/TL/Channels/TLRequestGetAdminedPublicChannels.cs
View file

@ -7,17 +7,20 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-1920105769)]
[TLObject(-122669393)]
public class TLRequestGetAdminedPublicChannels : TLMethod
{
public override int Constructor
{
get
{
return -1920105769;
return -122669393;
}
}
public int Flags { get; set; }
public bool ByLocation { get; set; }
public bool CheckLimit { get; set; }
public Messages.TLAbsChats Response { get; set; }
@ -28,12 +31,18 @@ namespace TeleSharp.TL.Channels
public override void DeserializeBody(BinaryReader br)
{
Flags = br.ReadInt32();
ByLocation = (Flags & 1) != 0;
CheckLimit = (Flags & 2) != 0;
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Flags);
}
public override void DeserializeResponse(BinaryReader br)

45
src/TeleSharp.TL/TL/Channels/TLRequestGetGroupsForDiscussion.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-170208392)]
public class TLRequestGetGroupsForDiscussion : TLMethod
{
public override int Constructor
{
get
{
return -170208392;
}
}
public Messages.TLAbsChats Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Messages.TLAbsChats)ObjectUtils.DeserializeObject(br);
}
}
}

45
src/TeleSharp.TL/TL/Channels/TLRequestGetInactiveChannels.cs Normal file
View file

@ -0,0 +1,45 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(300429806)]
public class TLRequestGetInactiveChannels : TLMethod
{
public override int Constructor
{
get
{
return 300429806;
}
}
public Messages.TLInactiveChats Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Messages.TLInactiveChats)ObjectUtils.DeserializeObject(br);
}
}
}

48
src/TeleSharp.TL/TL/Channels/TLRequestGetLeftChannels.cs Normal file
View file

@ -0,0 +1,48 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-2092831552)]
public class TLRequestGetLeftChannels : TLMethod
{
public override int Constructor
{
get
{
return -2092831552;
}
}
public int Offset { get; set; }
public Messages.TLAbsChats Response { get; set; }
public void ComputeFlags()
{
}
public override void DeserializeBody(BinaryReader br)
{
Offset = br.ReadInt32();
}
public override void SerializeBody(BinaryWriter bw)
{
bw.Write(Constructor);
bw.Write(Offset);
}
public override void DeserializeResponse(BinaryReader br)
{
Response = (Messages.TLAbsChats)ObjectUtils.DeserializeObject(br);
}
}
}

8
src/TeleSharp.TL/TL/Channels/TLRequestGetMessages.cs
View file

@ -7,19 +7,19 @@ using System.Threading.Tasks;
using TeleSharp.TL;
namespace TeleSharp.TL.Channels
{
[TLObject(-1814580409)]
[TLObject(-1383294429)]
public class TLRequestGetMessages : TLMethod
{
public override int Constructor
{
get
{
return -1814580409;
return -1383294429;
}
}
public TLAbsInputChannel Channel { get; set; }
public TLVector<int> Id { get; set; }
public TLVector<TLAbsInputMessage> Id { get; set; }
public Messages.TLAbsMessages Response { get; set; }
@ -31,7 +31,7 @@ namespace TeleSharp.TL.Channels
public override void DeserializeBody(BinaryReader br)
{
Channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
Id = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
Id = (TLVector<TLAbsInputMessage>)ObjectUtils.DeserializeVector<TLAbsInputMessage>(br);
}

Some files were not shown because too many files have changed in this diff Show more