Redesign Everything

TeleSharp.TL/ObjectDeserializer.cs

@@ -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
+{
+    public class ObjectUtils
+    {
+        public static object DeserializeObject(BinaryReader reader)
+        {
+            int Constructor = reader.ReadInt32();
+            object obj;
+            Type t =null;
+            try {
+                t = TLContext.getType(Constructor);
+                obj = Activator.CreateInstance(t);
+            }
+            catch(Exception ex)
+            {
+                throw new InvalidDataException("Constructor Invalid Or Context.Init Not Called !");
+            }
+            if (t.IsSubclassOf(typeof(TLMethod)))
+            {
+                ((TLMethod)obj).deserializeResponse(reader);
+                return obj;
+            }
+            else if (t.IsSubclassOf(typeof(TLObject)))
+            {
+                ((TLObject)obj).DeserializeBody(reader);
+                return obj;
+            }
+            else throw new NotImplementedException("Weird Type : " + t.Namespace + " | " + t.Name);
+        }
+        public static void SerializeObject(object  obj,BinaryWriter writer)
+        {
+            ((TLObject)obj).SerializeBody(writer);
+        }
+        public static TLVector<T> DeserializeVector<T>(BinaryReader reader)
+        {
+            if (reader.ReadInt32() != 481674261) throw new InvalidDataException("Bad Constructor");
+            TLVector<T> t = new TLVector<T>();
+            t.DeserializeBody(reader);
+            return t;
+        }
+    }
+}

TeleSharp.TL/Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("TeleSharp.TL")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("TeleSharp.TL")]
+[assembly: AssemblyCopyright("Copyright ©  2016")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("d6144517-91d2-4880-86df-e9ff5d7f383a")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

TeleSharp.TL/TL/Account/TLAbsPassword.cs

@@ -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 TLAbsPassword : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Account/TLAuthorizations.cs

@@ -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(307276766)]
+    public class TLAuthorizations : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 307276766;
+            }
+        }
+
+             public TLVector<TLAuthorization> authorizations {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            authorizations = (TLVector<TLAuthorization>)ObjectUtils.DeserializeVector<TLAuthorization>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(authorizations,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Account/TLNoPassword.cs

@@ -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(-1764049896)]
+    public class TLNoPassword : TLAbsPassword
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1764049896;
+            }
+        }
+
+             public byte[] new_salt {get;set;}
+     public string email_unconfirmed_pattern {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            new_salt = BytesUtil.Deserialize(br);
+email_unconfirmed_pattern = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            BytesUtil.Serialize(new_salt,bw);
+StringUtil.Serialize(email_unconfirmed_pattern,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Account/TLPassword.cs

@@ -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(2081952796)]
+    public class TLPassword : TLAbsPassword
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 2081952796;
+            }
+        }
+
+             public byte[] current_salt {get;set;}
+     public byte[] new_salt {get;set;}
+     public string hint {get;set;}
+     public bool has_recovery {get;set;}
+     public string email_unconfirmed_pattern {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            current_salt = BytesUtil.Deserialize(br);
+new_salt = BytesUtil.Deserialize(br);
+hint = StringUtil.Deserialize(br);
+has_recovery = BoolUtil.Deserialize(br);
+email_unconfirmed_pattern = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            BytesUtil.Serialize(current_salt,bw);
+BytesUtil.Serialize(new_salt,bw);
+StringUtil.Serialize(hint,bw);
+BoolUtil.Serialize(has_recovery,bw);
+StringUtil.Serialize(email_unconfirmed_pattern,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Account/TLPasswordInputSettings.cs

@@ -0,0 +1,80 @@
+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(-2037289493)]
+    public class TLPasswordInputSettings : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -2037289493;
+            }
+        }
+
+             public int flags {get;set;}
+     public byte[] new_salt {get;set;}
+     public byte[] new_password_hash {get;set;}
+     public string hint {get;set;}
+     public string email {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = new_salt != null ? (flags | 1) : (flags & ~1);
+flags = new_password_hash != null ? (flags | 1) : (flags & ~1);
+flags = hint != null ? (flags | 1) : (flags & ~1);
+flags = email != null ? (flags | 2) : (flags & ~2);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+if ((flags & 1) != 0)
+new_salt = BytesUtil.Deserialize(br);
+else
+new_salt = null;
+
+if ((flags & 1) != 0)
+new_password_hash = BytesUtil.Deserialize(br);
+else
+new_password_hash = null;
+
+if ((flags & 1) != 0)
+hint = StringUtil.Deserialize(br);
+else
+hint = null;
+
+if ((flags & 2) != 0)
+email = StringUtil.Deserialize(br);
+else
+email = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+if ((flags & 1) != 0)
+BytesUtil.Serialize(new_salt,bw);
+if ((flags & 1) != 0)
+BytesUtil.Serialize(new_password_hash,bw);
+if ((flags & 1) != 0)
+StringUtil.Serialize(hint,bw);
+if ((flags & 2) != 0)
+StringUtil.Serialize(email,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Account/TLPasswordSettings.cs

@@ -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(-1212732749)]
+    public class TLPasswordSettings : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1212732749;
+            }
+        }
+
+             public string email {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);
+
+        }
+    }
+}

TeleSharp.TL/TL/Account/TLPrivacyRules.cs

@@ -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(1430961007)]
+    public class TLPrivacyRules : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1430961007;
+            }
+        }
+
+             public TLVector<TLAbsPrivacyRule> rules {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            rules = (TLVector<TLAbsPrivacyRule>)ObjectUtils.DeserializeVector<TLAbsPrivacyRule>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(rules,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Account/TLRequestChangePhone.cs

@@ -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(1891839707)]
+    public class TLRequestChangePhone : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1891839707;
+            }
+        }
+
+                public string phone_number {get;set;}
+        public string phone_code_hash {get;set;}
+        public string phone_code {get;set;}
+        public TLAbsUser Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            phone_number = StringUtil.Deserialize(br);
+phone_code_hash = StringUtil.Deserialize(br);
+phone_code = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(phone_number,bw);
+StringUtil.Serialize(phone_code_hash,bw);
+StringUtil.Serialize(phone_code,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUser)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestCheckUsername.cs

@@ -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(655677548)]
+    public class TLRequestCheckUsername : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 655677548;
+            }
+        }
+
+                public string username {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            username = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(username,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestDeleteAccount.cs

@@ -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(1099779595)]
+    public class TLRequestDeleteAccount : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1099779595;
+            }
+        }
+
+                public string reason {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            reason = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(reason,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestGetAccountTTL.cs

@@ -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(150761757)]
+    public class TLRequestGetAccountTTL : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 150761757;
+            }
+        }
+
+                public TLAccountDaysTTL 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 = (TLAccountDaysTTL)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestGetAuthorizations.cs

@@ -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(-484392616)]
+    public class TLRequestGetAuthorizations : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -484392616;
+            }
+        }
+
+                public Account.TLAuthorizations 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.TLAuthorizations)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestGetNotifySettings.cs

@@ -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(313765169)]
+    public class TLRequestGetNotifySettings : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 313765169;
+            }
+        }
+
+                public TLAbsInputNotifyPeer peer {get;set;}
+        public TLAbsPeerNotifySettings Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputNotifyPeer)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsPeerNotifySettings)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestGetPassword.cs

@@ -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(1418342645)]
+    public class TLRequestGetPassword : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1418342645;
+            }
+        }
+
+                public Account.TLAbsPassword 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.TLAbsPassword)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestGetPasswordSettings.cs

@@ -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(-1131605573)]
+    public class TLRequestGetPasswordSettings : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1131605573;
+            }
+        }
+
+                public byte[] current_password_hash {get;set;}
+        public Account.TLPasswordSettings Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            current_password_hash = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            BytesUtil.Serialize(current_password_hash,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Account.TLPasswordSettings)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestGetPrivacy.cs

@@ -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(-623130288)]
+    public class TLRequestGetPrivacy : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -623130288;
+            }
+        }
+
+                public TLAbsInputPrivacyKey key {get;set;}
+        public Account.TLPrivacyRules Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            key = (TLAbsInputPrivacyKey)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(key,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Account.TLPrivacyRules)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestGetWallPapers.cs

@@ -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(-1068696894)]
+    public class TLRequestGetWallPapers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1068696894;
+            }
+        }
+
+                public TLVector<TLAbsWallPaper> 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<TLAbsWallPaper>)ObjectUtils.DeserializeVector<TLAbsWallPaper>(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestRegisterDevice.cs

@@ -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(1669245048)]
+    public class TLRequestRegisterDevice : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1669245048;
+            }
+        }
+
+                public int token_type {get;set;}
+        public string token {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            token_type = br.ReadInt32();
+token = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(token_type);
+StringUtil.Serialize(token,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestReportPeer.cs

@@ -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(-1374118561)]
+    public class TLRequestReportPeer : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1374118561;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public TLAbsReportReason reason {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+reason = (TLAbsReportReason)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+ObjectUtils.SerializeObject(reason,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestResetAuthorization.cs

@@ -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(-545786948)]
+    public class TLRequestResetAuthorization : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -545786948;
+            }
+        }
+
+                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);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestResetNotifySettings.cs

@@ -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(-612493497)]
+    public class TLRequestResetNotifySettings : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -612493497;
+            }
+        }
+
+                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);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestSendChangePhoneCode.cs

@@ -0,0 +1,66 @@
+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(149257707)]
+    public class TLRequestSendChangePhoneCode : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 149257707;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool allow_flashcall {get;set;}
+        public string phone_number {get;set;}
+        public bool? current_number {get;set;}
+        public Auth.TLSentCode Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = allow_flashcall ? (flags | 1) : (flags & ~1);
+flags = current_number != null ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+allow_flashcall = (flags & 1) != 0;
+phone_number = StringUtil.Deserialize(br);
+if ((flags & 1) != 0)
+current_number = BoolUtil.Deserialize(br);
+else
+current_number = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+StringUtil.Serialize(phone_number,bw);
+if ((flags & 1) != 0)
+BoolUtil.Serialize(current_number.Value,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLSentCode)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestSetAccountTTL.cs

@@ -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(608323678)]
+    public class TLRequestSetAccountTTL : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 608323678;
+            }
+        }
+
+                public TLAccountDaysTTL ttl {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            ttl = (TLAccountDaysTTL)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(ttl,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestSetPrivacy.cs

@@ -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(-906486552)]
+    public class TLRequestSetPrivacy : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -906486552;
+            }
+        }
+
+                public TLAbsInputPrivacyKey key {get;set;}
+        public TLVector<TLAbsInputPrivacyRule> rules {get;set;}
+        public Account.TLPrivacyRules Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            key = (TLAbsInputPrivacyKey)ObjectUtils.DeserializeObject(br);
+rules = (TLVector<TLAbsInputPrivacyRule>)ObjectUtils.DeserializeVector<TLAbsInputPrivacyRule>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(key,bw);
+ObjectUtils.SerializeObject(rules,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Account.TLPrivacyRules)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestUnregisterDevice.cs

@@ -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(1707432768)]
+    public class TLRequestUnregisterDevice : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1707432768;
+            }
+        }
+
+                public int token_type {get;set;}
+        public string token {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            token_type = br.ReadInt32();
+token = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(token_type);
+StringUtil.Serialize(token,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestUpdateDeviceLocked.cs

@@ -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(954152242)]
+    public class TLRequestUpdateDeviceLocked : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 954152242;
+            }
+        }
+
+                public int period {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            period = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(period);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestUpdateNotifySettings.cs

@@ -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(-2067899501)]
+    public class TLRequestUpdateNotifySettings : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -2067899501;
+            }
+        }
+
+                public TLAbsInputNotifyPeer peer {get;set;}
+        public TLInputPeerNotifySettings settings {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputNotifyPeer)ObjectUtils.DeserializeObject(br);
+settings = (TLInputPeerNotifySettings)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+ObjectUtils.SerializeObject(settings,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestUpdatePasswordSettings.cs

@@ -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(-92517498)]
+    public class TLRequestUpdatePasswordSettings : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -92517498;
+            }
+        }
+
+                public byte[] current_password_hash {get;set;}
+        public Account.TLPasswordInputSettings new_settings {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            current_password_hash = BytesUtil.Deserialize(br);
+new_settings = (Account.TLPasswordInputSettings)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            BytesUtil.Serialize(current_password_hash,bw);
+ObjectUtils.SerializeObject(new_settings,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestUpdateProfile.cs

@@ -0,0 +1,77 @@
+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(2018596725)]
+    public class TLRequestUpdateProfile : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 2018596725;
+            }
+        }
+
+                public int flags {get;set;}
+        public string first_name {get;set;}
+        public string last_name {get;set;}
+        public string about {get;set;}
+        public TLAbsUser Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = first_name != null ? (flags | 1) : (flags & ~1);
+flags = last_name != null ? (flags | 2) : (flags & ~2);
+flags = about != null ? (flags | 4) : (flags & ~4);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+if ((flags & 1) != 0)
+first_name = StringUtil.Deserialize(br);
+else
+first_name = null;
+
+if ((flags & 2) != 0)
+last_name = StringUtil.Deserialize(br);
+else
+last_name = null;
+
+if ((flags & 4) != 0)
+about = StringUtil.Deserialize(br);
+else
+about = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+if ((flags & 1) != 0)
+StringUtil.Serialize(first_name,bw);
+if ((flags & 2) != 0)
+StringUtil.Serialize(last_name,bw);
+if ((flags & 4) != 0)
+StringUtil.Serialize(about,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUser)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestUpdateStatus.cs

@@ -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(1713919532)]
+    public class TLRequestUpdateStatus : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1713919532;
+            }
+        }
+
+                public bool offline {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            offline = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            BoolUtil.Serialize(offline,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Account/TLRequestUpdateUsername.cs

@@ -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(1040964988)]
+    public class TLRequestUpdateUsername : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1040964988;
+            }
+        }
+
+                public string username {get;set;}
+        public TLAbsUser Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            username = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(username,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUser)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLAbsCodeType.cs

@@ -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 TLAbsCodeType : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Auth/TLAbsSentCodeType.cs

@@ -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 TLAbsSentCodeType : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Auth/TLAuthorization.cs

@@ -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.Auth
+{
+	[TLObject(-16553231)]
+    public class TLAuthorization : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -16553231;
+            }
+        }
+
+             public TLAbsUser user {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            user = (TLAbsUser)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(user,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLCheckedPhone.cs

@@ -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.Auth
+{
+	[TLObject(-2128698738)]
+    public class TLCheckedPhone : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -2128698738;
+            }
+        }
+
+             public bool phone_registered {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            phone_registered = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            BoolUtil.Serialize(phone_registered,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLCodeTypeCall.cs

@@ -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.Auth
+{
+	[TLObject(1948046307)]
+    public class TLCodeTypeCall : TLAbsCodeType
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1948046307;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLCodeTypeFlashCall.cs

@@ -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.Auth
+{
+	[TLObject(577556219)]
+    public class TLCodeTypeFlashCall : TLAbsCodeType
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 577556219;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLCodeTypeSms.cs

@@ -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.Auth
+{
+	[TLObject(1923290508)]
+    public class TLCodeTypeSms : TLAbsCodeType
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1923290508;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLExportedAuthorization.cs

@@ -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(-543777747)]
+    public class TLExportedAuthorization : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -543777747;
+            }
+        }
+
+             public int id {get;set;}
+     public byte[] bytes {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = br.ReadInt32();
+bytes = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(id);
+BytesUtil.Serialize(bytes,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLPasswordRecovery.cs

@@ -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.Auth
+{
+	[TLObject(326715557)]
+    public class TLPasswordRecovery : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 326715557;
+            }
+        }
+
+             public string email_pattern {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            email_pattern = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(email_pattern,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestBindTempAuthKey.cs

@@ -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.Auth
+{
+	[TLObject(-841733627)]
+    public class TLRequestBindTempAuthKey : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -841733627;
+            }
+        }
+
+                public long perm_auth_key_id {get;set;}
+        public long nonce {get;set;}
+        public int expires_at {get;set;}
+        public byte[] encrypted_message {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            perm_auth_key_id = br.ReadInt64();
+nonce = br.ReadInt64();
+expires_at = br.ReadInt32();
+encrypted_message = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(perm_auth_key_id);
+bw.Write(nonce);
+bw.Write(expires_at);
+BytesUtil.Serialize(encrypted_message,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestCancelCode.cs

@@ -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.Auth
+{
+	[TLObject(520357240)]
+    public class TLRequestCancelCode : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 520357240;
+            }
+        }
+
+                public string phone_number {get;set;}
+        public string phone_code_hash {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            phone_number = StringUtil.Deserialize(br);
+phone_code_hash = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(phone_number,bw);
+StringUtil.Serialize(phone_code_hash,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestCheckPassword.cs

@@ -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(174260510)]
+    public class TLRequestCheckPassword : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 174260510;
+            }
+        }
+
+                public byte[] password_hash {get;set;}
+        public Auth.TLAuthorization Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            password_hash = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            BytesUtil.Serialize(password_hash,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestCheckPhone.cs

@@ -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(1877286395)]
+    public class TLRequestCheckPhone : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1877286395;
+            }
+        }
+
+                public string phone_number {get;set;}
+        public Auth.TLCheckedPhone Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            phone_number = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(phone_number,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLCheckedPhone)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestExportAuthorization.cs

@@ -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(-440401971)]
+    public class TLRequestExportAuthorization : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -440401971;
+            }
+        }
+
+                public int dc_id {get;set;}
+        public Auth.TLExportedAuthorization Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            dc_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(dc_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLExportedAuthorization)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestImportAuthorization.cs

@@ -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.Auth
+{
+	[TLObject(-470837741)]
+    public class TLRequestImportAuthorization : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -470837741;
+            }
+        }
+
+                public int id {get;set;}
+        public byte[] bytes {get;set;}
+        public Auth.TLAuthorization Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = br.ReadInt32();
+bytes = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(id);
+BytesUtil.Serialize(bytes,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestImportBotAuthorization.cs

@@ -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.Auth
+{
+	[TLObject(1738800940)]
+    public class TLRequestImportBotAuthorization : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1738800940;
+            }
+        }
+
+                public int flags {get;set;}
+        public int api_id {get;set;}
+        public string api_hash {get;set;}
+        public string bot_auth_token {get;set;}
+        public Auth.TLAuthorization Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+api_id = br.ReadInt32();
+api_hash = StringUtil.Deserialize(br);
+bot_auth_token = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+bw.Write(api_id);
+StringUtil.Serialize(api_hash,bw);
+StringUtil.Serialize(bot_auth_token,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestLogOut.cs

@@ -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(1461180992)]
+    public class TLRequestLogOut : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1461180992;
+            }
+        }
+
+                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);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestRecoverPassword.cs

@@ -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(1319464594)]
+    public class TLRequestRecoverPassword : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1319464594;
+            }
+        }
+
+                public string code {get;set;}
+        public Auth.TLAuthorization 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 = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestRequestPasswordRecovery.cs

@@ -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(-661144474)]
+    public class TLRequestRequestPasswordRecovery : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -661144474;
+            }
+        }
+
+                public Auth.TLPasswordRecovery 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 = (Auth.TLPasswordRecovery)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestResendCode.cs

@@ -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.Auth
+{
+	[TLObject(1056025023)]
+    public class TLRequestResendCode : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1056025023;
+            }
+        }
+
+                public string phone_number {get;set;}
+        public string phone_code_hash {get;set;}
+        public Auth.TLSentCode Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            phone_number = StringUtil.Deserialize(br);
+phone_code_hash = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(phone_number,bw);
+StringUtil.Serialize(phone_code_hash,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLSentCode)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestResetAuthorizations.cs

@@ -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(-1616179942)]
+    public class TLRequestResetAuthorizations : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1616179942;
+            }
+        }
+
+                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);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestSendCode.cs

@@ -0,0 +1,72 @@
+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(-2035355412)]
+    public class TLRequestSendCode : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -2035355412;
+            }
+        }
+
+        public int flags { get; set; }
+        public bool allow_flashcall { get; set; }
+        public string phone_number { get; set; }
+        public bool? current_number { get; set; }
+        public int api_id { get; set; }
+        public string api_hash { get; set; }
+        public Auth.TLSentCode Response { get; set; }
+
+
+        public void ComputeFlags()
+        {
+            flags = 0;
+            flags = allow_flashcall ? (flags | 1) : (flags & ~1);
+            flags = current_number != null ? (flags | 1) : (flags & ~1);
+
+        }
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+            allow_flashcall = (flags & 1) != 0;
+            phone_number = StringUtil.Deserialize(br);
+            if ((flags & 1) != 0)
+                current_number = BoolUtil.Deserialize(br);
+            else
+                current_number = null;
+
+            api_id = br.ReadInt32();
+            api_hash = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+            bw.Write(Constructor);
+            ComputeFlags();
+            bw.Write(flags);
+
+            StringUtil.Serialize(phone_number, bw);
+            if ((flags & 1) != 0)
+                BoolUtil.Serialize(current_number.Value, bw);
+            bw.Write(api_id);
+            StringUtil.Serialize(api_hash, bw);
+
+        }
+        public override void deserializeResponse(BinaryReader br)
+        {
+            Response = (Auth.TLSentCode)ObjectUtils.DeserializeObject(br);
+
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestSendInvites.cs

@@ -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.Auth
+{
+	[TLObject(1998331287)]
+    public class TLRequestSendInvites : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1998331287;
+            }
+        }
+
+                public TLVector<string> phone_numbers {get;set;}
+        public string message {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            phone_numbers = (TLVector<string>)ObjectUtils.DeserializeVector<string>(br);
+message = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(phone_numbers,bw);
+StringUtil.Serialize(message,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestSignIn.cs

@@ -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(-1126886015)]
+    public class TLRequestSignIn : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1126886015;
+            }
+        }
+
+                public string phone_number {get;set;}
+        public string phone_code_hash {get;set;}
+        public string phone_code {get;set;}
+        public Auth.TLAuthorization Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            phone_number = StringUtil.Deserialize(br);
+phone_code_hash = StringUtil.Deserialize(br);
+phone_code = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(phone_number,bw);
+StringUtil.Serialize(phone_code_hash,bw);
+StringUtil.Serialize(phone_code,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLRequestSignUp.cs

@@ -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.Auth
+{
+	[TLObject(453408308)]
+    public class TLRequestSignUp : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 453408308;
+            }
+        }
+
+                public string phone_number {get;set;}
+        public string phone_code_hash {get;set;}
+        public string phone_code {get;set;}
+        public string first_name {get;set;}
+        public string last_name {get;set;}
+        public Auth.TLAuthorization Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            phone_number = StringUtil.Deserialize(br);
+phone_code_hash = StringUtil.Deserialize(br);
+phone_code = StringUtil.Deserialize(br);
+first_name = StringUtil.Deserialize(br);
+last_name = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(phone_number,bw);
+StringUtil.Serialize(phone_code_hash,bw);
+StringUtil.Serialize(phone_code,bw);
+StringUtil.Serialize(first_name,bw);
+StringUtil.Serialize(last_name,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Auth.TLAuthorization)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Auth/TLSentCode.cs

@@ -0,0 +1,72 @@
+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(1577067778)]
+    public class TLSentCode : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1577067778;
+            }
+        }
+
+             public int flags {get;set;}
+     public bool phone_registered {get;set;}
+     public Auth.TLAbsSentCodeType type {get;set;}
+     public string phone_code_hash {get;set;}
+     public Auth.TLAbsCodeType next_type {get;set;}
+     public int? timeout {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = phone_registered ? (flags | 1) : (flags & ~1);
+flags = next_type != null ? (flags | 2) : (flags & ~2);
+flags = timeout != null ? (flags | 4) : (flags & ~4);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+phone_registered = (flags & 1) != 0;
+type = (Auth.TLAbsSentCodeType)ObjectUtils.DeserializeObject(br);
+phone_code_hash = StringUtil.Deserialize(br);
+if ((flags & 2) != 0)
+next_type = (Auth.TLAbsCodeType)ObjectUtils.DeserializeObject(br);
+else
+next_type = null;
+
+if ((flags & 4) != 0)
+timeout = br.ReadInt32();
+else
+timeout = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(type,bw);
+StringUtil.Serialize(phone_code_hash,bw);
+if ((flags & 2) != 0)
+ObjectUtils.SerializeObject(next_type,bw);
+if ((flags & 4) != 0)
+bw.Write(timeout.Value);
+
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLSentCodeTypeApp.cs

@@ -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.Auth
+{
+	[TLObject(1035688326)]
+    public class TLSentCodeTypeApp : TLAbsSentCodeType
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1035688326;
+            }
+        }
+
+             public int length {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            length = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(length);
+
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLSentCodeTypeCall.cs

@@ -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.Auth
+{
+	[TLObject(1398007207)]
+    public class TLSentCodeTypeCall : TLAbsSentCodeType
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1398007207;
+            }
+        }
+
+             public int length {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            length = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(length);
+
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLSentCodeTypeFlashCall.cs

@@ -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.Auth
+{
+	[TLObject(-1425815847)]
+    public class TLSentCodeTypeFlashCall : TLAbsSentCodeType
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1425815847;
+            }
+        }
+
+             public string pattern {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            pattern = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(pattern,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Auth/TLSentCodeTypeSms.cs

@@ -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.Auth
+{
+	[TLObject(-1073693790)]
+    public class TLSentCodeTypeSms : TLAbsSentCodeType
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1073693790;
+            }
+        }
+
+             public int length {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            length = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(length);
+
+        }
+    }
+}

TeleSharp.TL/TL/Channels/TLChannelParticipant.cs

@@ -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(-791039645)]
+    public class TLChannelParticipant : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -791039645;
+            }
+        }
+
+             public TLAbsChannelParticipant participant {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            participant = (TLAbsChannelParticipant)ObjectUtils.DeserializeObject(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(participant,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Channels/TLChannelParticipants.cs

@@ -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(-177282392)]
+    public class TLChannelParticipants : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -177282392;
+            }
+        }
+
+             public int count {get;set;}
+     public TLVector<TLAbsChannelParticipant> participants {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            count = br.ReadInt32();
+participants = (TLVector<TLAbsChannelParticipant>)ObjectUtils.DeserializeVector<TLAbsChannelParticipant>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(count);
+ObjectUtils.SerializeObject(participants,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestCheckUsername.cs

@@ -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.Channels
+{
+	[TLObject(283557164)]
+    public class TLRequestCheckUsername : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 283557164;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public string username {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+username = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+StringUtil.Serialize(username,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestCreateChannel.cs

@@ -0,0 +1,64 @@
+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(-192332417)]
+    public class TLRequestCreateChannel : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -192332417;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool broadcast {get;set;}
+        public bool megagroup {get;set;}
+        public string title {get;set;}
+        public string about {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = broadcast ? (flags | 1) : (flags & ~1);
+flags = megagroup ? (flags | 2) : (flags & ~2);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+broadcast = (flags & 1) != 0;
+megagroup = (flags & 2) != 0;
+title = StringUtil.Deserialize(br);
+about = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+
+StringUtil.Serialize(title,bw);
+StringUtil.Serialize(about,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestDeleteChannel.cs

@@ -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(-1072619549)]
+    public class TLRequestDeleteChannel : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1072619549;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestDeleteMessages.cs

@@ -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.Channels
+{
+	[TLObject(-2067661490)]
+    public class TLRequestDeleteMessages : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -2067661490;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLVector<int> id {get;set;}
+        public Messages.TLAffectedMessages Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+id = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAffectedMessages)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestDeleteUserHistory.cs

@@ -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.Channels
+{
+	[TLObject(-787622117)]
+    public class TLRequestDeleteUserHistory : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -787622117;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public Messages.TLAffectedHistory Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(user_id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAffectedHistory)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestEditAbout.cs

@@ -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.Channels
+{
+	[TLObject(333610782)]
+    public class TLRequestEditAbout : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 333610782;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public string about {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+about = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+StringUtil.Serialize(about,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestEditAdmin.cs

@@ -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(-344583728)]
+    public class TLRequestEditAdmin : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -344583728;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public TLAbsChannelParticipantRole role {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+role = (TLAbsChannelParticipantRole)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(user_id,bw);
+ObjectUtils.SerializeObject(role,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestEditPhoto.cs

@@ -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.Channels
+{
+	[TLObject(-248621111)]
+    public class TLRequestEditPhoto : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -248621111;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsInputChatPhoto photo {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+photo = (TLAbsInputChatPhoto)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(photo,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestEditTitle.cs

@@ -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.Channels
+{
+	[TLObject(1450044624)]
+    public class TLRequestEditTitle : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1450044624;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public string title {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+title = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+StringUtil.Serialize(title,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestExportInvite.cs

@@ -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(-950663035)]
+    public class TLRequestExportInvite : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -950663035;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsExportedChatInvite Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsExportedChatInvite)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestExportMessageLink.cs

@@ -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.Channels
+{
+	[TLObject(-934882771)]
+    public class TLRequestExportMessageLink : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -934882771;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public int id {get;set;}
+        public TLExportedMessageLink Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+bw.Write(id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLExportedMessageLink)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestGetChannels.cs

@@ -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(176122811)]
+    public class TLRequestGetChannels : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 176122811;
+            }
+        }
+
+                public TLVector<TLAbsInputChannel> id {get;set;}
+        public Messages.TLChats Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = (TLVector<TLAbsInputChannel>)ObjectUtils.DeserializeVector<TLAbsInputChannel>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLChats)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestGetFullChannel.cs

@@ -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(141781513)]
+    public class TLRequestGetFullChannel : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 141781513;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public Messages.TLChatFull Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLChatFull)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestGetMessages.cs

@@ -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.Channels
+{
+	[TLObject(-1814580409)]
+    public class TLRequestGetMessages : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1814580409;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLVector<int> id {get;set;}
+        public Messages.TLAbsMessages Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+id = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsMessages)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestGetParticipant.cs

@@ -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.Channels
+{
+	[TLObject(1416484774)]
+    public class TLRequestGetParticipant : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1416484774;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public Channels.TLChannelParticipant Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(user_id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Channels.TLChannelParticipant)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestGetParticipants.cs

@@ -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.Channels
+{
+	[TLObject(618237842)]
+    public class TLRequestGetParticipants : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 618237842;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsChannelParticipantsFilter filter {get;set;}
+        public int offset {get;set;}
+        public int limit {get;set;}
+        public Channels.TLChannelParticipants Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+filter = (TLAbsChannelParticipantsFilter)ObjectUtils.DeserializeObject(br);
+offset = br.ReadInt32();
+limit = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(filter,bw);
+bw.Write(offset);
+bw.Write(limit);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Channels.TLChannelParticipants)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestInviteToChannel.cs

@@ -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.Channels
+{
+	[TLObject(429865580)]
+    public class TLRequestInviteToChannel : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 429865580;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLVector<TLAbsInputUser> users {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+users = (TLVector<TLAbsInputUser>)ObjectUtils.DeserializeVector<TLAbsInputUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestJoinChannel.cs

@@ -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(615851205)]
+    public class TLRequestJoinChannel : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 615851205;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestKickFromChannel.cs

@@ -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(-1502421484)]
+    public class TLRequestKickFromChannel : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1502421484;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public bool kicked {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+kicked = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(user_id,bw);
+BoolUtil.Serialize(kicked,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestLeaveChannel.cs

@@ -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(-130635115)]
+    public class TLRequestLeaveChannel : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -130635115;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestReadHistory.cs

@@ -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.Channels
+{
+	[TLObject(-871347913)]
+    public class TLRequestReadHistory : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -871347913;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public int max_id {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+max_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+bw.Write(max_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestReportSpam.cs

@@ -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(-32999408)]
+    public class TLRequestReportSpam : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -32999408;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public TLVector<int> id {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+id = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+ObjectUtils.SerializeObject(user_id,bw);
+ObjectUtils.SerializeObject(id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestToggleInvites.cs

@@ -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.Channels
+{
+	[TLObject(1231065863)]
+    public class TLRequestToggleInvites : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1231065863;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public bool enabled {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+enabled = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+BoolUtil.Serialize(enabled,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestToggleSignatures.cs

@@ -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.Channels
+{
+	[TLObject(527021574)]
+    public class TLRequestToggleSignatures : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 527021574;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public bool enabled {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+enabled = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+BoolUtil.Serialize(enabled,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestUpdatePinnedMessage.cs

@@ -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.Channels
+{
+	[TLObject(-1490162350)]
+    public class TLRequestUpdatePinnedMessage : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1490162350;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool silent {get;set;}
+        public TLAbsInputChannel channel {get;set;}
+        public int id {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = silent ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+silent = (flags & 1) != 0;
+channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(channel,bw);
+bw.Write(id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Channels/TLRequestUpdateUsername.cs

@@ -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.Channels
+{
+	[TLObject(890549214)]
+    public class TLRequestUpdateUsername : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 890549214;
+            }
+        }
+
+                public TLAbsInputChannel channel {get;set;}
+        public string username {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            channel = (TLAbsInputChannel)ObjectUtils.DeserializeObject(br);
+username = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(channel,bw);
+StringUtil.Serialize(username,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Contacts/TLAbsBlocked.cs

@@ -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.Contacts
+{
+    public abstract class TLAbsBlocked : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Contacts/TLAbsContacts.cs

@@ -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.Contacts
+{
+    public abstract class TLAbsContacts : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Contacts/TLAbsTopPeers.cs

@@ -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.Contacts
+{
+    public abstract class TLAbsTopPeers : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Contacts/TLBlocked.cs

@@ -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.Contacts
+{
+	[TLObject(471043349)]
+    public class TLBlocked : TLAbsBlocked
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 471043349;
+            }
+        }
+
+             public TLVector<TLContactBlocked> blocked {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            blocked = (TLVector<TLContactBlocked>)ObjectUtils.DeserializeVector<TLContactBlocked>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(blocked,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Contacts/TLBlockedSlice.cs

@@ -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.Contacts
+{
+	[TLObject(-1878523231)]
+    public class TLBlockedSlice : TLAbsBlocked
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1878523231;
+            }
+        }
+
+             public int count {get;set;}
+     public TLVector<TLContactBlocked> blocked {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            count = br.ReadInt32();
+blocked = (TLVector<TLContactBlocked>)ObjectUtils.DeserializeVector<TLContactBlocked>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(count);
+ObjectUtils.SerializeObject(blocked,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Contacts/TLContacts.cs

@@ -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.Contacts
+{
+	[TLObject(1871416498)]
+    public class TLContacts : TLAbsContacts
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1871416498;
+            }
+        }
+
+             public TLVector<TLContact> contacts {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            contacts = (TLVector<TLContact>)ObjectUtils.DeserializeVector<TLContact>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(contacts,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Contacts/TLContactsNotModified.cs

@@ -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.Contacts
+{
+	[TLObject(-1219778094)]
+    public class TLContactsNotModified : TLAbsContacts
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1219778094;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/Contacts/TLFound.cs

@@ -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.Contacts
+{
+	[TLObject(446822276)]
+    public class TLFound : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 446822276;
+            }
+        }
+
+             public TLVector<TLAbsPeer> results {get;set;}
+     public TLVector<TLAbsChat> chats {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            results = (TLVector<TLAbsPeer>)ObjectUtils.DeserializeVector<TLAbsPeer>(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(results,bw);
+ObjectUtils.SerializeObject(chats,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Contacts/TLImportedContacts.cs

@@ -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.Contacts
+{
+	[TLObject(-1387117803)]
+    public class TLImportedContacts : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1387117803;
+            }
+        }
+
+             public TLVector<TLImportedContact> imported {get;set;}
+     public TLVector<long> retry_contacts {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            imported = (TLVector<TLImportedContact>)ObjectUtils.DeserializeVector<TLImportedContact>(br);
+retry_contacts = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(imported,bw);
+ObjectUtils.SerializeObject(retry_contacts,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}