Redesign Everything

TeleSharp.TL/TL/Messages/TLAbsAllStickers.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.Messages
+{
+    public abstract class TLAbsAllStickers : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLAbsDhConfig.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.Messages
+{
+    public abstract class TLAbsDhConfig : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLAbsDialogs.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.Messages
+{
+    public abstract class TLAbsDialogs : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLAbsMessages.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.Messages
+{
+    public abstract class TLAbsMessages : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLAbsSavedGifs.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.Messages
+{
+    public abstract class TLAbsSavedGifs : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLAbsSentEncryptedMessage.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.Messages
+{
+    public abstract class TLAbsSentEncryptedMessage : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLAbsStickers.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.Messages
+{
+    public abstract class TLAbsStickers : TLObject
+    {
+    }
+}

TeleSharp.TL/TL/Messages/TLAffectedHistory.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.Messages
+{
+	[TLObject(-1269012015)]
+    public class TLAffectedHistory : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1269012015;
+            }
+        }
+
+             public int pts {get;set;}
+     public int pts_count {get;set;}
+     public int offset {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            pts = br.ReadInt32();
+pts_count = br.ReadInt32();
+offset = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(pts);
+bw.Write(pts_count);
+bw.Write(offset);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLAffectedMessages.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.Messages
+{
+	[TLObject(-2066640507)]
+    public class TLAffectedMessages : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -2066640507;
+            }
+        }
+
+             public int pts {get;set;}
+     public int pts_count {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            pts = br.ReadInt32();
+pts_count = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(pts);
+bw.Write(pts_count);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLAllStickers.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.Messages
+{
+	[TLObject(-302170017)]
+    public class TLAllStickers : TLAbsAllStickers
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -302170017;
+            }
+        }
+
+             public int hash {get;set;}
+     public TLVector<TLStickerSet> sets {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = br.ReadInt32();
+sets = (TLVector<TLStickerSet>)ObjectUtils.DeserializeVector<TLStickerSet>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(hash);
+ObjectUtils.SerializeObject(sets,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLAllStickersNotModified.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.Messages
+{
+	[TLObject(-395967805)]
+    public class TLAllStickersNotModified : TLAbsAllStickers
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -395967805;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLBotCallbackAnswer.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.Messages
+{
+	[TLObject(308605382)]
+    public class TLBotCallbackAnswer : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 308605382;
+            }
+        }
+
+             public int flags {get;set;}
+     public bool alert {get;set;}
+     public string message {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = alert ? (flags | 2) : (flags & ~2);
+flags = message != null ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+alert = (flags & 2) != 0;
+if ((flags & 1) != 0)
+message = StringUtil.Deserialize(br);
+else
+message = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+if ((flags & 1) != 0)
+StringUtil.Serialize(message,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLBotResults.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.Messages
+{
+	[TLObject(627509670)]
+    public class TLBotResults : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 627509670;
+            }
+        }
+
+             public int flags {get;set;}
+     public bool gallery {get;set;}
+     public long query_id {get;set;}
+     public string next_offset {get;set;}
+     public TLInlineBotSwitchPM switch_pm {get;set;}
+     public TLVector<TLAbsBotInlineResult> results {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = gallery ? (flags | 1) : (flags & ~1);
+flags = next_offset != null ? (flags | 2) : (flags & ~2);
+flags = switch_pm != null ? (flags | 4) : (flags & ~4);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+gallery = (flags & 1) != 0;
+query_id = br.ReadInt64();
+if ((flags & 2) != 0)
+next_offset = StringUtil.Deserialize(br);
+else
+next_offset = null;
+
+if ((flags & 4) != 0)
+switch_pm = (TLInlineBotSwitchPM)ObjectUtils.DeserializeObject(br);
+else
+switch_pm = null;
+
+results = (TLVector<TLAbsBotInlineResult>)ObjectUtils.DeserializeVector<TLAbsBotInlineResult>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+bw.Write(query_id);
+if ((flags & 2) != 0)
+StringUtil.Serialize(next_offset,bw);
+if ((flags & 4) != 0)
+ObjectUtils.SerializeObject(switch_pm,bw);
+ObjectUtils.SerializeObject(results,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLChannelMessages.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.Messages
+{
+	[TLObject(-1725551049)]
+    public class TLChannelMessages : TLAbsMessages
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1725551049;
+            }
+        }
+
+             public int flags {get;set;}
+     public int pts {get;set;}
+     public int count {get;set;}
+     public TLVector<TLAbsMessage> messages {get;set;}
+     public TLVector<TLAbsChat> chats {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+pts = br.ReadInt32();
+count = br.ReadInt32();
+messages = (TLVector<TLAbsMessage>)ObjectUtils.DeserializeVector<TLAbsMessage>(br);
+chats = (TLVector<TLAbsChat>)ObjectUtils.DeserializeVector<TLAbsChat>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+bw.Write(pts);
+bw.Write(count);
+ObjectUtils.SerializeObject(messages,bw);
+ObjectUtils.SerializeObject(chats,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLChatFull.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.Messages
+{
+	[TLObject(-438840932)]
+    public class TLChatFull : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -438840932;
+            }
+        }
+
+             public TLAbsChatFull full_chat {get;set;}
+     public TLVector<TLAbsChat> chats {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            full_chat = (TLAbsChatFull)ObjectUtils.DeserializeObject(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(full_chat,bw);
+ObjectUtils.SerializeObject(chats,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLChats.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.Messages
+{
+	[TLObject(1694474197)]
+    public class TLChats : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1694474197;
+            }
+        }
+
+             public TLVector<TLAbsChat> chats {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chats = (TLVector<TLAbsChat>)ObjectUtils.DeserializeVector<TLAbsChat>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(chats,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLDhConfig.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.Messages
+{
+	[TLObject(740433629)]
+    public class TLDhConfig : TLAbsDhConfig
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 740433629;
+            }
+        }
+
+             public int g {get;set;}
+     public byte[] p {get;set;}
+     public int version {get;set;}
+     public byte[] random {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            g = br.ReadInt32();
+p = BytesUtil.Deserialize(br);
+version = br.ReadInt32();
+random = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(g);
+BytesUtil.Serialize(p,bw);
+bw.Write(version);
+BytesUtil.Serialize(random,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLDhConfigNotModified.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.Messages
+{
+	[TLObject(-1058912715)]
+    public class TLDhConfigNotModified : TLAbsDhConfig
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1058912715;
+            }
+        }
+
+             public byte[] random {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            random = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            BytesUtil.Serialize(random,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLDialogs.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.Messages
+{
+	[TLObject(364538944)]
+    public class TLDialogs : TLAbsDialogs
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 364538944;
+            }
+        }
+
+             public TLVector<TLDialog> dialogs {get;set;}
+     public TLVector<TLAbsMessage> messages {get;set;}
+     public TLVector<TLAbsChat> chats {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            dialogs = (TLVector<TLDialog>)ObjectUtils.DeserializeVector<TLDialog>(br);
+messages = (TLVector<TLAbsMessage>)ObjectUtils.DeserializeVector<TLAbsMessage>(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(dialogs,bw);
+ObjectUtils.SerializeObject(messages,bw);
+ObjectUtils.SerializeObject(chats,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLDialogsSlice.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.Messages
+{
+	[TLObject(1910543603)]
+    public class TLDialogsSlice : TLAbsDialogs
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1910543603;
+            }
+        }
+
+             public int count {get;set;}
+     public TLVector<TLDialog> dialogs {get;set;}
+     public TLVector<TLAbsMessage> messages {get;set;}
+     public TLVector<TLAbsChat> chats {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            count = br.ReadInt32();
+dialogs = (TLVector<TLDialog>)ObjectUtils.DeserializeVector<TLDialog>(br);
+messages = (TLVector<TLAbsMessage>)ObjectUtils.DeserializeVector<TLAbsMessage>(br);
+chats = (TLVector<TLAbsChat>)ObjectUtils.DeserializeVector<TLAbsChat>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(count);
+ObjectUtils.SerializeObject(dialogs,bw);
+ObjectUtils.SerializeObject(messages,bw);
+ObjectUtils.SerializeObject(chats,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLFoundGifs.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.Messages
+{
+	[TLObject(1158290442)]
+    public class TLFoundGifs : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1158290442;
+            }
+        }
+
+             public int next_offset {get;set;}
+     public TLVector<TLAbsFoundGif> results {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            next_offset = br.ReadInt32();
+results = (TLVector<TLAbsFoundGif>)ObjectUtils.DeserializeVector<TLAbsFoundGif>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(next_offset);
+ObjectUtils.SerializeObject(results,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLMessageEditData.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.Messages
+{
+	[TLObject(649453030)]
+    public class TLMessageEditData : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 649453030;
+            }
+        }
+
+             public int flags {get;set;}
+     public bool caption {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = caption ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+caption = (flags & 1) != 0;
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLMessages.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.Messages
+{
+	[TLObject(-1938715001)]
+    public class TLMessages : TLAbsMessages
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1938715001;
+            }
+        }
+
+             public TLVector<TLAbsMessage> messages {get;set;}
+     public TLVector<TLAbsChat> chats {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            messages = (TLVector<TLAbsMessage>)ObjectUtils.DeserializeVector<TLAbsMessage>(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(messages,bw);
+ObjectUtils.SerializeObject(chats,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLMessagesSlice.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.Messages
+{
+	[TLObject(189033187)]
+    public class TLMessagesSlice : TLAbsMessages
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 189033187;
+            }
+        }
+
+             public int count {get;set;}
+     public TLVector<TLAbsMessage> messages {get;set;}
+     public TLVector<TLAbsChat> chats {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            count = br.ReadInt32();
+messages = (TLVector<TLAbsMessage>)ObjectUtils.DeserializeVector<TLAbsMessage>(br);
+chats = (TLVector<TLAbsChat>)ObjectUtils.DeserializeVector<TLAbsChat>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(count);
+ObjectUtils.SerializeObject(messages,bw);
+ObjectUtils.SerializeObject(chats,bw);
+ObjectUtils.SerializeObject(users,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLPeerDialogs.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.Messages
+{
+	[TLObject(863093588)]
+    public class TLPeerDialogs : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 863093588;
+            }
+        }
+
+             public TLVector<TLDialog> dialogs {get;set;}
+     public TLVector<TLAbsMessage> messages {get;set;}
+     public TLVector<TLAbsChat> chats {get;set;}
+     public TLVector<TLAbsUser> users {get;set;}
+     public Updates.TLState state {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            dialogs = (TLVector<TLDialog>)ObjectUtils.DeserializeVector<TLDialog>(br);
+messages = (TLVector<TLAbsMessage>)ObjectUtils.DeserializeVector<TLAbsMessage>(br);
+chats = (TLVector<TLAbsChat>)ObjectUtils.DeserializeVector<TLAbsChat>(br);
+users = (TLVector<TLAbsUser>)ObjectUtils.DeserializeVector<TLAbsUser>(br);
+state = (Updates.TLState)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(dialogs,bw);
+ObjectUtils.SerializeObject(messages,bw);
+ObjectUtils.SerializeObject(chats,bw);
+ObjectUtils.SerializeObject(users,bw);
+ObjectUtils.SerializeObject(state,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestAcceptEncryption.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.Messages
+{
+	[TLObject(1035731989)]
+    public class TLRequestAcceptEncryption : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1035731989;
+            }
+        }
+
+                public TLInputEncryptedChat peer {get;set;}
+        public byte[] g_b {get;set;}
+        public long key_fingerprint {get;set;}
+        public TLAbsEncryptedChat Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLInputEncryptedChat)ObjectUtils.DeserializeObject(br);
+g_b = BytesUtil.Deserialize(br);
+key_fingerprint = br.ReadInt64();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+BytesUtil.Serialize(g_b,bw);
+bw.Write(key_fingerprint);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsEncryptedChat)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestAddChatUser.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.Messages
+{
+	[TLObject(-106911223)]
+    public class TLRequestAddChatUser : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -106911223;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public int fwd_limit {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+fwd_limit = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+ObjectUtils.SerializeObject(user_id,bw);
+bw.Write(fwd_limit);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestCheckChatInvite.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.Messages
+{
+	[TLObject(1051570619)]
+    public class TLRequestCheckChatInvite : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1051570619;
+            }
+        }
+
+                public string hash {get;set;}
+        public TLAbsChatInvite Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(hash,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsChatInvite)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestCreateChat.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.Messages
+{
+	[TLObject(164303470)]
+    public class TLRequestCreateChat : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 164303470;
+            }
+        }
+
+                public TLVector<TLAbsInputUser> users {get;set;}
+        public string title {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            users = (TLVector<TLAbsInputUser>)ObjectUtils.DeserializeVector<TLAbsInputUser>(br);
+title = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(users,bw);
+StringUtil.Serialize(title,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestDeleteChatUser.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.Messages
+{
+	[TLObject(-530505962)]
+    public class TLRequestDeleteChatUser : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -530505962;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+ObjectUtils.SerializeObject(user_id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestDeleteHistory.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.Messages
+{
+	[TLObject(469850889)]
+    public class TLRequestDeleteHistory : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 469850889;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool just_clear {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public int max_id {get;set;}
+        public Messages.TLAffectedHistory Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = just_clear ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+just_clear = (flags & 1) != 0;
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+max_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(peer,bw);
+bw.Write(max_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAffectedHistory)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

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

TeleSharp.TL/TL/Messages/TLRequestDiscardEncryption.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.Messages
+{
+	[TLObject(-304536635)]
+    public class TLRequestDiscardEncryption : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -304536635;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestEditChatAdmin.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.Messages
+{
+	[TLObject(-1444503762)]
+    public class TLRequestEditChatAdmin : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1444503762;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public TLAbsInputUser user_id {get;set;}
+        public bool is_admin {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+is_admin = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+ObjectUtils.SerializeObject(user_id,bw);
+BoolUtil.Serialize(is_admin,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestEditChatPhoto.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.Messages
+{
+	[TLObject(-900957736)]
+    public class TLRequestEditChatPhoto : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -900957736;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public TLAbsInputChatPhoto photo {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+photo = (TLAbsInputChatPhoto)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+ObjectUtils.SerializeObject(photo,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestEditChatTitle.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.Messages
+{
+	[TLObject(-599447467)]
+    public class TLRequestEditChatTitle : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -599447467;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public string title {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+title = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+StringUtil.Serialize(title,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestEditInlineBotMessage.cs

@@ -0,0 +1,84 @@
+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.Messages
+{
+	[TLObject(319564933)]
+    public class TLRequestEditInlineBotMessage : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 319564933;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool no_webpage {get;set;}
+        public TLInputBotInlineMessageID id {get;set;}
+        public string message {get;set;}
+        public TLAbsReplyMarkup reply_markup {get;set;}
+        public TLVector<TLAbsMessageEntity> entities {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = no_webpage ? (flags | 2) : (flags & ~2);
+flags = message != null ? (flags | 2048) : (flags & ~2048);
+flags = reply_markup != null ? (flags | 4) : (flags & ~4);
+flags = entities != null ? (flags | 8) : (flags & ~8);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+no_webpage = (flags & 2) != 0;
+id = (TLInputBotInlineMessageID)ObjectUtils.DeserializeObject(br);
+if ((flags & 2048) != 0)
+message = StringUtil.Deserialize(br);
+else
+message = null;
+
+if ((flags & 4) != 0)
+reply_markup = (TLAbsReplyMarkup)ObjectUtils.DeserializeObject(br);
+else
+reply_markup = null;
+
+if ((flags & 8) != 0)
+entities = (TLVector<TLAbsMessageEntity>)ObjectUtils.DeserializeVector<TLAbsMessageEntity>(br);
+else
+entities = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(id,bw);
+if ((flags & 2048) != 0)
+StringUtil.Serialize(message,bw);
+if ((flags & 4) != 0)
+ObjectUtils.SerializeObject(reply_markup,bw);
+if ((flags & 8) != 0)
+ObjectUtils.SerializeObject(entities,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestEditMessage.cs

@@ -0,0 +1,87 @@
+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.Messages
+{
+	[TLObject(-829299510)]
+    public class TLRequestEditMessage : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -829299510;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool no_webpage {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public int id {get;set;}
+        public string message {get;set;}
+        public TLAbsReplyMarkup reply_markup {get;set;}
+        public TLVector<TLAbsMessageEntity> entities {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = no_webpage ? (flags | 2) : (flags & ~2);
+flags = message != null ? (flags | 2048) : (flags & ~2048);
+flags = reply_markup != null ? (flags | 4) : (flags & ~4);
+flags = entities != null ? (flags | 8) : (flags & ~8);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+no_webpage = (flags & 2) != 0;
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+id = br.ReadInt32();
+if ((flags & 2048) != 0)
+message = StringUtil.Deserialize(br);
+else
+message = null;
+
+if ((flags & 4) != 0)
+reply_markup = (TLAbsReplyMarkup)ObjectUtils.DeserializeObject(br);
+else
+reply_markup = null;
+
+if ((flags & 8) != 0)
+entities = (TLVector<TLAbsMessageEntity>)ObjectUtils.DeserializeVector<TLAbsMessageEntity>(br);
+else
+entities = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+ObjectUtils.SerializeObject(peer,bw);
+bw.Write(id);
+if ((flags & 2048) != 0)
+StringUtil.Serialize(message,bw);
+if ((flags & 4) != 0)
+ObjectUtils.SerializeObject(reply_markup,bw);
+if ((flags & 8) != 0)
+ObjectUtils.SerializeObject(entities,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestExportChatInvite.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.Messages
+{
+	[TLObject(2106086025)]
+    public class TLRequestExportChatInvite : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 2106086025;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public TLAbsExportedChatInvite Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsExportedChatInvite)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestForwardMessage.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.Messages
+{
+	[TLObject(865483769)]
+    public class TLRequestForwardMessage : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 865483769;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public int id {get;set;}
+        public long random_id {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+id = br.ReadInt32();
+random_id = br.ReadInt64();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(id);
+bw.Write(random_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestForwardMessages.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(1888354709)]
+    public class TLRequestForwardMessages : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1888354709;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool silent {get;set;}
+        public bool background {get;set;}
+        public TLAbsInputPeer from_peer {get;set;}
+        public TLVector<int> id {get;set;}
+        public TLVector<long> random_id {get;set;}
+        public TLAbsInputPeer to_peer {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = silent ? (flags | 32) : (flags & ~32);
+flags = background ? (flags | 64) : (flags & ~64);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+silent = (flags & 32) != 0;
+background = (flags & 64) != 0;
+from_peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+id = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
+random_id = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+to_peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+
+ObjectUtils.SerializeObject(from_peer,bw);
+ObjectUtils.SerializeObject(id,bw);
+ObjectUtils.SerializeObject(random_id,bw);
+ObjectUtils.SerializeObject(to_peer,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetAllDrafts.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.Messages
+{
+	[TLObject(1782549861)]
+    public class TLRequestGetAllDrafts : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1782549861;
+            }
+        }
+
+                public TLAbsUpdates 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 = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetAllStickers.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.Messages
+{
+	[TLObject(479598769)]
+    public class TLRequestGetAllStickers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 479598769;
+            }
+        }
+
+                public int hash {get;set;}
+        public Messages.TLAbsAllStickers Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(hash);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsAllStickers)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetBotCallbackAnswer.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.Messages
+{
+	[TLObject(-1494659324)]
+    public class TLRequestGetBotCallbackAnswer : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1494659324;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public int msg_id {get;set;}
+        public byte[] data {get;set;}
+        public Messages.TLBotCallbackAnswer Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+msg_id = br.ReadInt32();
+data = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(msg_id);
+BytesUtil.Serialize(data,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLBotCallbackAnswer)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetChats.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.Messages
+{
+	[TLObject(1013621127)]
+    public class TLRequestGetChats : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1013621127;
+            }
+        }
+
+                public TLVector<int> id {get;set;}
+        public Messages.TLChats Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = (TLVector<int>)ObjectUtils.DeserializeVector<int>(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/Messages/TLRequestGetDhConfig.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.Messages
+{
+	[TLObject(651135312)]
+    public class TLRequestGetDhConfig : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 651135312;
+            }
+        }
+
+                public int version {get;set;}
+        public int random_length {get;set;}
+        public Messages.TLAbsDhConfig Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            version = br.ReadInt32();
+random_length = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(version);
+bw.Write(random_length);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsDhConfig)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetDialogs.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.Messages
+{
+	[TLObject(1799878989)]
+    public class TLRequestGetDialogs : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1799878989;
+            }
+        }
+
+                public int offset_date {get;set;}
+        public int offset_id {get;set;}
+        public TLAbsInputPeer offset_peer {get;set;}
+        public int limit {get;set;}
+        public Messages.TLAbsDialogs Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            offset_date = br.ReadInt32();
+offset_id = br.ReadInt32();
+offset_peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+limit = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(offset_date);
+bw.Write(offset_id);
+ObjectUtils.SerializeObject(offset_peer,bw);
+bw.Write(limit);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsDialogs)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetDocumentByHash.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.Messages
+{
+	[TLObject(864953444)]
+    public class TLRequestGetDocumentByHash : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 864953444;
+            }
+        }
+
+                public byte[] sha256 {get;set;}
+        public int size {get;set;}
+        public string mime_type {get;set;}
+        public TLAbsDocument Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            sha256 = BytesUtil.Deserialize(br);
+size = br.ReadInt32();
+mime_type = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            BytesUtil.Serialize(sha256,bw);
+bw.Write(size);
+StringUtil.Serialize(mime_type,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsDocument)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetFullChat.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.Messages
+{
+	[TLObject(998448230)]
+    public class TLRequestGetFullChat : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 998448230;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public Messages.TLChatFull Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLChatFull)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetHistory.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.Messages
+{
+	[TLObject(-1347868602)]
+    public class TLRequestGetHistory : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1347868602;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public int offset_id {get;set;}
+        public int offset_date {get;set;}
+        public int add_offset {get;set;}
+        public int limit {get;set;}
+        public int max_id {get;set;}
+        public int min_id {get;set;}
+        public Messages.TLAbsMessages Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+offset_id = br.ReadInt32();
+offset_date = br.ReadInt32();
+add_offset = br.ReadInt32();
+limit = br.ReadInt32();
+max_id = br.ReadInt32();
+min_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(offset_id);
+bw.Write(offset_date);
+bw.Write(add_offset);
+bw.Write(limit);
+bw.Write(max_id);
+bw.Write(min_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsMessages)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetInlineBotResults.cs

@@ -0,0 +1,71 @@
+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.Messages
+{
+	[TLObject(1364105629)]
+    public class TLRequestGetInlineBotResults : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1364105629;
+            }
+        }
+
+                public int flags {get;set;}
+        public TLAbsInputUser bot {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public TLAbsInputGeoPoint geo_point {get;set;}
+        public string query {get;set;}
+        public string offset {get;set;}
+        public Messages.TLBotResults Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = geo_point != null ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+bot = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+if ((flags & 1) != 0)
+geo_point = (TLAbsInputGeoPoint)ObjectUtils.DeserializeObject(br);
+else
+geo_point = null;
+
+query = StringUtil.Deserialize(br);
+offset = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+ObjectUtils.SerializeObject(bot,bw);
+ObjectUtils.SerializeObject(peer,bw);
+if ((flags & 1) != 0)
+ObjectUtils.SerializeObject(geo_point,bw);
+StringUtil.Serialize(query,bw);
+StringUtil.Serialize(offset,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLBotResults)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetMessageEditData.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.Messages
+{
+	[TLObject(-39416522)]
+    public class TLRequestGetMessageEditData : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -39416522;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public int id {get;set;}
+        public Messages.TLMessageEditData Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLMessageEditData)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

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

TeleSharp.TL/TL/Messages/TLRequestGetMessagesViews.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.Messages
+{
+	[TLObject(-993483427)]
+    public class TLRequestGetMessagesViews : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -993483427;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public TLVector<int> id {get;set;}
+        public bool increment {get;set;}
+        public TLVector<int> Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+id = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
+increment = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+ObjectUtils.SerializeObject(id,bw);
+BoolUtil.Serialize(increment,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLVector<int>)ObjectUtils.DeserializeVector<int>(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetPeerDialogs.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.Messages
+{
+	[TLObject(764901049)]
+    public class TLRequestGetPeerDialogs : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 764901049;
+            }
+        }
+
+                public TLVector<TLAbsInputPeer> peers {get;set;}
+        public Messages.TLPeerDialogs Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peers = (TLVector<TLAbsInputPeer>)ObjectUtils.DeserializeVector<TLAbsInputPeer>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peers,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLPeerDialogs)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetPeerSettings.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.Messages
+{
+	[TLObject(913498268)]
+    public class TLRequestGetPeerSettings : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 913498268;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public TLPeerSettings Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLPeerSettings)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetSavedGifs.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.Messages
+{
+	[TLObject(-2084618926)]
+    public class TLRequestGetSavedGifs : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -2084618926;
+            }
+        }
+
+                public int hash {get;set;}
+        public Messages.TLAbsSavedGifs Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(hash);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsSavedGifs)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetStickerSet.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.Messages
+{
+	[TLObject(639215886)]
+    public class TLRequestGetStickerSet : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 639215886;
+            }
+        }
+
+                public TLAbsInputStickerSet stickerset {get;set;}
+        public Messages.TLStickerSet Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            stickerset = (TLAbsInputStickerSet)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(stickerset,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLStickerSet)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetStickers.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.Messages
+{
+	[TLObject(-1373446075)]
+    public class TLRequestGetStickers : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1373446075;
+            }
+        }
+
+                public string emoticon {get;set;}
+        public string hash {get;set;}
+        public Messages.TLAbsStickers Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            emoticon = StringUtil.Deserialize(br);
+hash = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(emoticon,bw);
+StringUtil.Serialize(hash,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsStickers)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestGetWebPagePreview.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.Messages
+{
+	[TLObject(623001124)]
+    public class TLRequestGetWebPagePreview : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 623001124;
+            }
+        }
+
+                public string message {get;set;}
+        public TLAbsMessageMedia Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            message = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(message,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsMessageMedia)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestHideReportSpam.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.Messages
+{
+	[TLObject(-1460572005)]
+    public class TLRequestHideReportSpam : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1460572005;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestImportChatInvite.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.Messages
+{
+	[TLObject(1817183516)]
+    public class TLRequestImportChatInvite : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1817183516;
+            }
+        }
+
+                public string hash {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(hash,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestInstallStickerSet.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.Messages
+{
+	[TLObject(2066793382)]
+    public class TLRequestInstallStickerSet : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 2066793382;
+            }
+        }
+
+                public TLAbsInputStickerSet stickerset {get;set;}
+        public bool disabled {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            stickerset = (TLAbsInputStickerSet)ObjectUtils.DeserializeObject(br);
+disabled = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(stickerset,bw);
+BoolUtil.Serialize(disabled,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestMigrateChat.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.Messages
+{
+	[TLObject(363051235)]
+    public class TLRequestMigrateChat : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 363051235;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestReadEncryptedHistory.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.Messages
+{
+	[TLObject(2135648522)]
+    public class TLRequestReadEncryptedHistory : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 2135648522;
+            }
+        }
+
+                public TLInputEncryptedChat peer {get;set;}
+        public int max_date {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLInputEncryptedChat)ObjectUtils.DeserializeObject(br);
+max_date = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(max_date);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/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.Messages
+{
+	[TLObject(238054714)]
+    public class TLRequestReadHistory : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 238054714;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public int max_id {get;set;}
+        public Messages.TLAffectedMessages Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+max_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(max_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAffectedMessages)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

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

TeleSharp.TL/TL/Messages/TLRequestReceivedMessages.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.Messages
+{
+	[TLObject(94983360)]
+    public class TLRequestReceivedMessages : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 94983360;
+            }
+        }
+
+                public int max_id {get;set;}
+        public TLVector<TLReceivedNotifyMessage> Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            max_id = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(max_id);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLVector<TLReceivedNotifyMessage>)ObjectUtils.DeserializeVector<TLReceivedNotifyMessage>(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestReceivedQueue.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.Messages
+{
+	[TLObject(1436924774)]
+    public class TLRequestReceivedQueue : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1436924774;
+            }
+        }
+
+                public int max_qts {get;set;}
+        public TLVector<long> Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            max_qts = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(max_qts);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestReorderStickerSets.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.Messages
+{
+	[TLObject(-1613775824)]
+    public class TLRequestReorderStickerSets : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1613775824;
+            }
+        }
+
+                public TLVector<long> order {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            order = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(order,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestReportSpam.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.Messages
+{
+	[TLObject(-820669733)]
+    public class TLRequestReportSpam : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -820669733;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestRequestEncryption.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.Messages
+{
+	[TLObject(-162681021)]
+    public class TLRequestRequestEncryption : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -162681021;
+            }
+        }
+
+                public TLAbsInputUser user_id {get;set;}
+        public int random_id {get;set;}
+        public byte[] g_a {get;set;}
+        public TLAbsEncryptedChat Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            user_id = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+random_id = br.ReadInt32();
+g_a = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(user_id,bw);
+bw.Write(random_id);
+BytesUtil.Serialize(g_a,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsEncryptedChat)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSaveDraft.cs

@@ -0,0 +1,78 @@
+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.Messages
+{
+	[TLObject(-1137057461)]
+    public class TLRequestSaveDraft : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1137057461;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool no_webpage {get;set;}
+        public int? reply_to_msg_id {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public string message {get;set;}
+        public TLVector<TLAbsMessageEntity> entities {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = no_webpage ? (flags | 2) : (flags & ~2);
+flags = reply_to_msg_id != null ? (flags | 1) : (flags & ~1);
+flags = entities != null ? (flags | 8) : (flags & ~8);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+no_webpage = (flags & 2) != 0;
+if ((flags & 1) != 0)
+reply_to_msg_id = br.ReadInt32();
+else
+reply_to_msg_id = null;
+
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+message = StringUtil.Deserialize(br);
+if ((flags & 8) != 0)
+entities = (TLVector<TLAbsMessageEntity>)ObjectUtils.DeserializeVector<TLAbsMessageEntity>(br);
+else
+entities = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+if ((flags & 1) != 0)
+bw.Write(reply_to_msg_id.Value);
+ObjectUtils.SerializeObject(peer,bw);
+StringUtil.Serialize(message,bw);
+if ((flags & 8) != 0)
+ObjectUtils.SerializeObject(entities,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSaveGif.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.Messages
+{
+	[TLObject(846868683)]
+    public class TLRequestSaveGif : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 846868683;
+            }
+        }
+
+                public TLAbsInputDocument id {get;set;}
+        public bool unsave {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            id = (TLAbsInputDocument)ObjectUtils.DeserializeObject(br);
+unsave = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(id,bw);
+BoolUtil.Serialize(unsave,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSearch.cs

@@ -0,0 +1,74 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TeleSharp.TL;
+namespace TeleSharp.TL.Messages
+{
+	[TLObject(-732523960)]
+    public class TLRequestSearch : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -732523960;
+            }
+        }
+
+                public int flags {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public string q {get;set;}
+        public TLAbsMessagesFilter filter {get;set;}
+        public int min_date {get;set;}
+        public int max_date {get;set;}
+        public int offset {get;set;}
+        public int max_id {get;set;}
+        public int limit {get;set;}
+        public Messages.TLAbsMessages Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+q = StringUtil.Deserialize(br);
+filter = (TLAbsMessagesFilter)ObjectUtils.DeserializeObject(br);
+min_date = br.ReadInt32();
+max_date = br.ReadInt32();
+offset = br.ReadInt32();
+max_id = br.ReadInt32();
+limit = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+ObjectUtils.SerializeObject(peer,bw);
+StringUtil.Serialize(q,bw);
+ObjectUtils.SerializeObject(filter,bw);
+bw.Write(min_date);
+bw.Write(max_date);
+bw.Write(offset);
+bw.Write(max_id);
+bw.Write(limit);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsMessages)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSearchGifs.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.Messages
+{
+	[TLObject(-1080395925)]
+    public class TLRequestSearchGifs : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1080395925;
+            }
+        }
+
+                public string q {get;set;}
+        public int offset {get;set;}
+        public Messages.TLFoundGifs Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            q = StringUtil.Deserialize(br);
+offset = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(q,bw);
+bw.Write(offset);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLFoundGifs)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSearchGlobal.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.Messages
+{
+	[TLObject(-1640190800)]
+    public class TLRequestSearchGlobal : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1640190800;
+            }
+        }
+
+                public string q {get;set;}
+        public int offset_date {get;set;}
+        public TLAbsInputPeer offset_peer {get;set;}
+        public int offset_id {get;set;}
+        public int limit {get;set;}
+        public Messages.TLAbsMessages Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            q = StringUtil.Deserialize(br);
+offset_date = br.ReadInt32();
+offset_peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+offset_id = br.ReadInt32();
+limit = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(q,bw);
+bw.Write(offset_date);
+ObjectUtils.SerializeObject(offset_peer,bw);
+bw.Write(offset_id);
+bw.Write(limit);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsMessages)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSendBroadcast.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.Messages
+{
+	[TLObject(-1082919718)]
+    public class TLRequestSendBroadcast : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1082919718;
+            }
+        }
+
+                public TLVector<TLAbsInputUser> contacts {get;set;}
+        public TLVector<long> random_id {get;set;}
+        public string message {get;set;}
+        public TLAbsInputMedia media {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            contacts = (TLVector<TLAbsInputUser>)ObjectUtils.DeserializeVector<TLAbsInputUser>(br);
+random_id = (TLVector<long>)ObjectUtils.DeserializeVector<long>(br);
+message = StringUtil.Deserialize(br);
+media = (TLAbsInputMedia)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(contacts,bw);
+ObjectUtils.SerializeObject(random_id,bw);
+StringUtil.Serialize(message,bw);
+ObjectUtils.SerializeObject(media,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSendEncrypted.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.Messages
+{
+	[TLObject(-1451792525)]
+    public class TLRequestSendEncrypted : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1451792525;
+            }
+        }
+
+                public TLInputEncryptedChat peer {get;set;}
+        public long random_id {get;set;}
+        public byte[] data {get;set;}
+        public Messages.TLAbsSentEncryptedMessage Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLInputEncryptedChat)ObjectUtils.DeserializeObject(br);
+random_id = br.ReadInt64();
+data = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(random_id);
+BytesUtil.Serialize(data,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsSentEncryptedMessage)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSendEncryptedFile.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.Messages
+{
+	[TLObject(-1701831834)]
+    public class TLRequestSendEncryptedFile : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1701831834;
+            }
+        }
+
+                public TLInputEncryptedChat peer {get;set;}
+        public long random_id {get;set;}
+        public byte[] data {get;set;}
+        public TLAbsInputEncryptedFile file {get;set;}
+        public Messages.TLAbsSentEncryptedMessage Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLInputEncryptedChat)ObjectUtils.DeserializeObject(br);
+random_id = br.ReadInt64();
+data = BytesUtil.Deserialize(br);
+file = (TLAbsInputEncryptedFile)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(random_id);
+BytesUtil.Serialize(data,bw);
+ObjectUtils.SerializeObject(file,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsSentEncryptedMessage)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSendEncryptedService.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.Messages
+{
+	[TLObject(852769188)]
+    public class TLRequestSendEncryptedService : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 852769188;
+            }
+        }
+
+                public TLInputEncryptedChat peer {get;set;}
+        public long random_id {get;set;}
+        public byte[] data {get;set;}
+        public Messages.TLAbsSentEncryptedMessage Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLInputEncryptedChat)ObjectUtils.DeserializeObject(br);
+random_id = br.ReadInt64();
+data = BytesUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+bw.Write(random_id);
+BytesUtil.Serialize(data,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (Messages.TLAbsSentEncryptedMessage)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSendInlineBotResult.cs

@@ -0,0 +1,83 @@
+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.Messages
+{
+	[TLObject(-1318189314)]
+    public class TLRequestSendInlineBotResult : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1318189314;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool silent {get;set;}
+        public bool background {get;set;}
+        public bool clear_draft {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public int? reply_to_msg_id {get;set;}
+        public long random_id {get;set;}
+        public long query_id {get;set;}
+        public string id {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = silent ? (flags | 32) : (flags & ~32);
+flags = background ? (flags | 64) : (flags & ~64);
+flags = clear_draft ? (flags | 128) : (flags & ~128);
+flags = reply_to_msg_id != null ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+silent = (flags & 32) != 0;
+background = (flags & 64) != 0;
+clear_draft = (flags & 128) != 0;
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+if ((flags & 1) != 0)
+reply_to_msg_id = br.ReadInt32();
+else
+reply_to_msg_id = null;
+
+random_id = br.ReadInt64();
+query_id = br.ReadInt64();
+id = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+
+
+ObjectUtils.SerializeObject(peer,bw);
+if ((flags & 1) != 0)
+bw.Write(reply_to_msg_id.Value);
+bw.Write(random_id);
+bw.Write(query_id);
+StringUtil.Serialize(id,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSendMedia.cs

@@ -0,0 +1,89 @@
+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.Messages
+{
+	[TLObject(-923703407)]
+    public class TLRequestSendMedia : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -923703407;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool silent {get;set;}
+        public bool background {get;set;}
+        public bool clear_draft {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public int? reply_to_msg_id {get;set;}
+        public TLAbsInputMedia media {get;set;}
+        public long random_id {get;set;}
+        public TLAbsReplyMarkup reply_markup {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = silent ? (flags | 32) : (flags & ~32);
+flags = background ? (flags | 64) : (flags & ~64);
+flags = clear_draft ? (flags | 128) : (flags & ~128);
+flags = reply_to_msg_id != null ? (flags | 1) : (flags & ~1);
+flags = reply_markup != null ? (flags | 4) : (flags & ~4);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+silent = (flags & 32) != 0;
+background = (flags & 64) != 0;
+clear_draft = (flags & 128) != 0;
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+if ((flags & 1) != 0)
+reply_to_msg_id = br.ReadInt32();
+else
+reply_to_msg_id = null;
+
+media = (TLAbsInputMedia)ObjectUtils.DeserializeObject(br);
+random_id = br.ReadInt64();
+if ((flags & 4) != 0)
+reply_markup = (TLAbsReplyMarkup)ObjectUtils.DeserializeObject(br);
+else
+reply_markup = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+
+
+ObjectUtils.SerializeObject(peer,bw);
+if ((flags & 1) != 0)
+bw.Write(reply_to_msg_id.Value);
+ObjectUtils.SerializeObject(media,bw);
+bw.Write(random_id);
+if ((flags & 4) != 0)
+ObjectUtils.SerializeObject(reply_markup,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSendMessage.cs

@@ -0,0 +1,102 @@
+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.Messages
+{
+	[TLObject(-91733382)]
+    public class TLRequestSendMessage : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -91733382;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool no_webpage {get;set;}
+        public bool silent {get;set;}
+        public bool background {get;set;}
+        public bool clear_draft {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public int? reply_to_msg_id {get;set;}
+        public string message {get;set;}
+        public long random_id {get;set;}
+        public TLAbsReplyMarkup reply_markup {get;set;}
+        public TLVector<TLAbsMessageEntity> entities {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = no_webpage ? (flags | 2) : (flags & ~2);
+flags = silent ? (flags | 32) : (flags & ~32);
+flags = background ? (flags | 64) : (flags & ~64);
+flags = clear_draft ? (flags | 128) : (flags & ~128);
+flags = reply_to_msg_id != null ? (flags | 1) : (flags & ~1);
+flags = reply_markup != null ? (flags | 4) : (flags & ~4);
+flags = entities != null ? (flags | 8) : (flags & ~8);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+no_webpage = (flags & 2) != 0;
+silent = (flags & 32) != 0;
+background = (flags & 64) != 0;
+clear_draft = (flags & 128) != 0;
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+if ((flags & 1) != 0)
+reply_to_msg_id = br.ReadInt32();
+else
+reply_to_msg_id = null;
+
+message = StringUtil.Deserialize(br);
+random_id = br.ReadInt64();
+if ((flags & 4) != 0)
+reply_markup = (TLAbsReplyMarkup)ObjectUtils.DeserializeObject(br);
+else
+reply_markup = null;
+
+if ((flags & 8) != 0)
+entities = (TLVector<TLAbsMessageEntity>)ObjectUtils.DeserializeVector<TLAbsMessageEntity>(br);
+else
+entities = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+
+
+
+ObjectUtils.SerializeObject(peer,bw);
+if ((flags & 1) != 0)
+bw.Write(reply_to_msg_id.Value);
+StringUtil.Serialize(message,bw);
+bw.Write(random_id);
+if ((flags & 4) != 0)
+ObjectUtils.SerializeObject(reply_markup,bw);
+if ((flags & 8) != 0)
+ObjectUtils.SerializeObject(entities,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSetBotCallbackAnswer.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.Messages
+{
+	[TLObject(1209817370)]
+    public class TLRequestSetBotCallbackAnswer : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1209817370;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool alert {get;set;}
+        public long query_id {get;set;}
+        public string message {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = alert ? (flags | 2) : (flags & ~2);
+flags = message != null ? (flags | 1) : (flags & ~1);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+alert = (flags & 2) != 0;
+query_id = br.ReadInt64();
+if ((flags & 1) != 0)
+message = StringUtil.Deserialize(br);
+else
+message = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+bw.Write(query_id);
+if ((flags & 1) != 0)
+StringUtil.Serialize(message,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSetEncryptedTyping.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.Messages
+{
+	[TLObject(2031374829)]
+    public class TLRequestSetEncryptedTyping : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 2031374829;
+            }
+        }
+
+                public TLInputEncryptedChat peer {get;set;}
+        public bool typing {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLInputEncryptedChat)ObjectUtils.DeserializeObject(br);
+typing = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+BoolUtil.Serialize(typing,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSetInlineBotResults.cs

@@ -0,0 +1,85 @@
+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.Messages
+{
+	[TLObject(-346119674)]
+    public class TLRequestSetInlineBotResults : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -346119674;
+            }
+        }
+
+                public int flags {get;set;}
+        public bool gallery {get;set;}
+        public bool @private {get;set;}
+        public long query_id {get;set;}
+        public TLVector<TLAbsInputBotInlineResult> results {get;set;}
+        public int cache_time {get;set;}
+        public string next_offset {get;set;}
+        public TLInlineBotSwitchPM switch_pm {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			flags = 0;
+flags = gallery ? (flags | 1) : (flags & ~1);
+flags = @private ? (flags | 2) : (flags & ~2);
+flags = next_offset != null ? (flags | 4) : (flags & ~4);
+flags = switch_pm != null ? (flags | 8) : (flags & ~8);
+
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            flags = br.ReadInt32();
+gallery = (flags & 1) != 0;
+@private = (flags & 2) != 0;
+query_id = br.ReadInt64();
+results = (TLVector<TLAbsInputBotInlineResult>)ObjectUtils.DeserializeVector<TLAbsInputBotInlineResult>(br);
+cache_time = br.ReadInt32();
+if ((flags & 4) != 0)
+next_offset = StringUtil.Deserialize(br);
+else
+next_offset = null;
+
+if ((flags & 8) != 0)
+switch_pm = (TLInlineBotSwitchPM)ObjectUtils.DeserializeObject(br);
+else
+switch_pm = null;
+
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ComputeFlags();
+bw.Write(flags);
+
+
+bw.Write(query_id);
+ObjectUtils.SerializeObject(results,bw);
+bw.Write(cache_time);
+if ((flags & 4) != 0)
+StringUtil.Serialize(next_offset,bw);
+if ((flags & 8) != 0)
+ObjectUtils.SerializeObject(switch_pm,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestSetTyping.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.Messages
+{
+	[TLObject(-1551737264)]
+    public class TLRequestSetTyping : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1551737264;
+            }
+        }
+
+                public TLAbsInputPeer peer {get;set;}
+        public TLAbsSendMessageAction action {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+action = (TLAbsSendMessageAction)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(peer,bw);
+ObjectUtils.SerializeObject(action,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestStartBot.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.Messages
+{
+	[TLObject(-421563528)]
+    public class TLRequestStartBot : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -421563528;
+            }
+        }
+
+                public TLAbsInputUser bot {get;set;}
+        public TLAbsInputPeer peer {get;set;}
+        public long random_id {get;set;}
+        public string start_param {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            bot = (TLAbsInputUser)ObjectUtils.DeserializeObject(br);
+peer = (TLAbsInputPeer)ObjectUtils.DeserializeObject(br);
+random_id = br.ReadInt64();
+start_param = StringUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(bot,bw);
+ObjectUtils.SerializeObject(peer,bw);
+bw.Write(random_id);
+StringUtil.Serialize(start_param,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestToggleChatAdmins.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.Messages
+{
+	[TLObject(-326379039)]
+    public class TLRequestToggleChatAdmins : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -326379039;
+            }
+        }
+
+                public int chat_id {get;set;}
+        public bool enabled {get;set;}
+        public TLAbsUpdates Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            chat_id = br.ReadInt32();
+enabled = BoolUtil.Deserialize(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(chat_id);
+BoolUtil.Serialize(enabled,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = (TLAbsUpdates)ObjectUtils.DeserializeObject(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLRequestUninstallStickerSet.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.Messages
+{
+	[TLObject(-110209570)]
+    public class TLRequestUninstallStickerSet : TLMethod
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -110209570;
+            }
+        }
+
+                public TLAbsInputStickerSet stickerset {get;set;}
+        public bool Response{ get; set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            stickerset = (TLAbsInputStickerSet)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(stickerset,bw);
+
+        }
+		public override void deserializeResponse(BinaryReader br)
+		{
+			Response = BoolUtil.Deserialize(br);
+
+		}
+    }
+}

TeleSharp.TL/TL/Messages/TLSavedGifs.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.Messages
+{
+	[TLObject(772213157)]
+    public class TLSavedGifs : TLAbsSavedGifs
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 772213157;
+            }
+        }
+
+             public int hash {get;set;}
+     public TLVector<TLAbsDocument> gifs {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = br.ReadInt32();
+gifs = (TLVector<TLAbsDocument>)ObjectUtils.DeserializeVector<TLAbsDocument>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(hash);
+ObjectUtils.SerializeObject(gifs,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLSavedGifsNotModified.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.Messages
+{
+	[TLObject(-402498398)]
+    public class TLSavedGifsNotModified : TLAbsSavedGifs
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -402498398;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLSentEncryptedFile.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.Messages
+{
+	[TLObject(-1802240206)]
+    public class TLSentEncryptedFile : TLAbsSentEncryptedMessage
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1802240206;
+            }
+        }
+
+             public int date {get;set;}
+     public TLAbsEncryptedFile file {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            date = br.ReadInt32();
+file = (TLAbsEncryptedFile)ObjectUtils.DeserializeObject(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(date);
+ObjectUtils.SerializeObject(file,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLSentEncryptedMessage.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.Messages
+{
+	[TLObject(1443858741)]
+    public class TLSentEncryptedMessage : TLAbsSentEncryptedMessage
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return 1443858741;
+            }
+        }
+
+             public int date {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            date = br.ReadInt32();
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            bw.Write(date);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLStickerSet.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.Messages
+{
+	[TLObject(-1240849242)]
+    public class TLStickerSet : TLObject
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1240849242;
+            }
+        }
+
+             public TLStickerSet @set {get;set;}
+     public TLVector<TLStickerPack> packs {get;set;}
+     public TLVector<TLAbsDocument> documents {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            @set = (TLStickerSet)ObjectUtils.DeserializeObject(br);
+packs = (TLVector<TLStickerPack>)ObjectUtils.DeserializeVector<TLStickerPack>(br);
+documents = (TLVector<TLAbsDocument>)ObjectUtils.DeserializeVector<TLAbsDocument>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            ObjectUtils.SerializeObject(@set,bw);
+ObjectUtils.SerializeObject(packs,bw);
+ObjectUtils.SerializeObject(documents,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLStickers.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.Messages
+{
+	[TLObject(-1970352846)]
+    public class TLStickers : TLAbsStickers
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -1970352846;
+            }
+        }
+
+             public string hash {get;set;}
+     public TLVector<TLAbsDocument> stickers {get;set;}
+
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            hash = StringUtil.Deserialize(br);
+stickers = (TLVector<TLAbsDocument>)ObjectUtils.DeserializeVector<TLAbsDocument>(br);
+
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            StringUtil.Serialize(hash,bw);
+ObjectUtils.SerializeObject(stickers,bw);
+
+        }
+    }
+}

TeleSharp.TL/TL/Messages/TLStickersNotModified.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.Messages
+{
+	[TLObject(-244016606)]
+    public class TLStickersNotModified : TLAbsStickers
+    {
+        public override int Constructor
+        {
+            get
+            {
+                return -244016606;
+            }
+        }
+
+        
+
+		public void ComputeFlags()
+		{
+			
+		}
+
+        public override void DeserializeBody(BinaryReader br)
+        {
+            
+        }
+
+        public override void SerializeBody(BinaryWriter bw)
+        {
+			bw.Write(Constructor);
+            
+        }
+    }
+}