Все подряд

.venv2/Lib/site-packages/telethon/tl/functions/__init__.py

@@ -0,0 +1,581 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+from . import account, auth, bots, channels, chatlists, contacts, folders, help, langpack, messages, payments, phone, photos, premium, stats, stickers, stories, updates, upload, users
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputClientProxy, TypeJSONValue, TypeMessageRange, TypeType, TypeX
+
+
+
+class DestroyAuthKeyRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xd1435160
+    SUBCLASS_OF_ID = 0x8291e68e
+
+    def to_dict(self):
+        return {
+            '_': 'DestroyAuthKeyRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'`QC\xd1',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class DestroySessionRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xe7512126
+    SUBCLASS_OF_ID = 0xaf0ce7bd
+
+    def __init__(self, session_id: int):
+        """
+        :returns DestroySessionRes: Instance of either DestroySessionOk, DestroySessionNone.
+        """
+        self.session_id = session_id
+
+    def to_dict(self):
+        return {
+            '_': 'DestroySessionRequest',
+            'session_id': self.session_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'&!Q\xe7',
+            struct.pack('<q', self.session_id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _session_id = reader.read_long()
+        return cls(session_id=_session_id)
+
+
+class GetFutureSaltsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xb921bd04
+    SUBCLASS_OF_ID = 0x1090f517
+
+    def __init__(self, num: int):
+        """
+        :returns FutureSalts: Instance of FutureSalts.
+        """
+        self.num = num
+
+    def to_dict(self):
+        return {
+            '_': 'GetFutureSaltsRequest',
+            'num': self.num
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x04\xbd!\xb9',
+            struct.pack('<i', self.num),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _num = reader.read_int()
+        return cls(num=_num)
+
+
+class InitConnectionRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xc1cd5ea9
+    SUBCLASS_OF_ID = 0xb7b2364b
+
+    def __init__(self, api_id: int, device_model: str, system_version: str, app_version: str, system_lang_code: str, lang_pack: str, lang_code: str, query: 'TypeX', proxy: Optional['TypeInputClientProxy']=None, params: Optional['TypeJSONValue']=None):
+        """
+        :returns X: This type has no constructors.
+        """
+        self.api_id = api_id
+        self.device_model = device_model
+        self.system_version = system_version
+        self.app_version = app_version
+        self.system_lang_code = system_lang_code
+        self.lang_pack = lang_pack
+        self.lang_code = lang_code
+        self.query = query
+        self.proxy = proxy
+        self.params = params
+
+    def to_dict(self):
+        return {
+            '_': 'InitConnectionRequest',
+            'api_id': self.api_id,
+            'device_model': self.device_model,
+            'system_version': self.system_version,
+            'app_version': self.app_version,
+            'system_lang_code': self.system_lang_code,
+            'lang_pack': self.lang_pack,
+            'lang_code': self.lang_code,
+            'query': self.query.to_dict() if isinstance(self.query, TLObject) else self.query,
+            'proxy': self.proxy.to_dict() if isinstance(self.proxy, TLObject) else self.proxy,
+            'params': self.params.to_dict() if isinstance(self.params, TLObject) else self.params
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xa9^\xcd\xc1',
+            struct.pack('<I', (0 if self.proxy is None or self.proxy is False else 1) | (0 if self.params is None or self.params is False else 2)),
+            struct.pack('<i', self.api_id),
+            self.serialize_bytes(self.device_model),
+            self.serialize_bytes(self.system_version),
+            self.serialize_bytes(self.app_version),
+            self.serialize_bytes(self.system_lang_code),
+            self.serialize_bytes(self.lang_pack),
+            self.serialize_bytes(self.lang_code),
+            b'' if self.proxy is None or self.proxy is False else (self.proxy._bytes()),
+            b'' if self.params is None or self.params is False else (self.params._bytes()),
+            self.query._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _api_id = reader.read_int()
+        _device_model = reader.tgread_string()
+        _system_version = reader.tgread_string()
+        _app_version = reader.tgread_string()
+        _system_lang_code = reader.tgread_string()
+        _lang_pack = reader.tgread_string()
+        _lang_code = reader.tgread_string()
+        if flags & 1:
+            _proxy = reader.tgread_object()
+        else:
+            _proxy = None
+        if flags & 2:
+            _params = reader.tgread_object()
+        else:
+            _params = None
+        _query = reader.tgread_object()
+        return cls(api_id=_api_id, device_model=_device_model, system_version=_system_version, app_version=_app_version, system_lang_code=_system_lang_code, lang_pack=_lang_pack, lang_code=_lang_code, query=_query, proxy=_proxy, params=_params)
+
+
+class InvokeAfterMsgRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xcb9f372d
+    SUBCLASS_OF_ID = 0xb7b2364b
+
+    def __init__(self, msg_id: int, query: 'TypeX'):
+        """
+        :returns X: This type has no constructors.
+        """
+        self.msg_id = msg_id
+        self.query = query
+
+    def to_dict(self):
+        return {
+            '_': 'InvokeAfterMsgRequest',
+            'msg_id': self.msg_id,
+            'query': self.query.to_dict() if isinstance(self.query, TLObject) else self.query
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'-7\x9f\xcb',
+            struct.pack('<q', self.msg_id),
+            self.query._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _msg_id = reader.read_long()
+        _query = reader.tgread_object()
+        return cls(msg_id=_msg_id, query=_query)
+
+
+class InvokeAfterMsgsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x3dc4b4f0
+    SUBCLASS_OF_ID = 0xb7b2364b
+
+    def __init__(self, msg_ids: List[int], query: 'TypeX'):
+        """
+        :returns X: This type has no constructors.
+        """
+        self.msg_ids = msg_ids
+        self.query = query
+
+    def to_dict(self):
+        return {
+            '_': 'InvokeAfterMsgsRequest',
+            'msg_ids': [] if self.msg_ids is None else self.msg_ids[:],
+            'query': self.query.to_dict() if isinstance(self.query, TLObject) else self.query
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xf0\xb4\xc4=',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.msg_ids)),b''.join(struct.pack('<q', x) for x in self.msg_ids),
+            self.query._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _msg_ids = []
+        for _ in range(reader.read_int()):
+            _x = reader.read_long()
+            _msg_ids.append(_x)
+
+        _query = reader.tgread_object()
+        return cls(msg_ids=_msg_ids, query=_query)
+
+
+class InvokeWithLayerRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xda9b0d0d
+    SUBCLASS_OF_ID = 0xb7b2364b
+
+    def __init__(self, layer: int, query: 'TypeX'):
+        """
+        :returns X: This type has no constructors.
+        """
+        self.layer = layer
+        self.query = query
+
+    def to_dict(self):
+        return {
+            '_': 'InvokeWithLayerRequest',
+            'layer': self.layer,
+            'query': self.query.to_dict() if isinstance(self.query, TLObject) else self.query
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\r\r\x9b\xda',
+            struct.pack('<i', self.layer),
+            self.query._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _layer = reader.read_int()
+        _query = reader.tgread_object()
+        return cls(layer=_layer, query=_query)
+
+
+class InvokeWithMessagesRangeRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x365275f2
+    SUBCLASS_OF_ID = 0xb7b2364b
+
+    def __init__(self, range: 'TypeMessageRange', query: 'TypeX'):
+        """
+        :returns X: This type has no constructors.
+        """
+        self.range = range
+        self.query = query
+
+    def to_dict(self):
+        return {
+            '_': 'InvokeWithMessagesRangeRequest',
+            'range': self.range.to_dict() if isinstance(self.range, TLObject) else self.range,
+            'query': self.query.to_dict() if isinstance(self.query, TLObject) else self.query
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xf2uR6',
+            self.range._bytes(),
+            self.query._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _range = reader.tgread_object()
+        _query = reader.tgread_object()
+        return cls(range=_range, query=_query)
+
+
+class InvokeWithTakeoutRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xaca9fd2e
+    SUBCLASS_OF_ID = 0xb7b2364b
+
+    def __init__(self, takeout_id: int, query: 'TypeX'):
+        """
+        :returns X: This type has no constructors.
+        """
+        self.takeout_id = takeout_id
+        self.query = query
+
+    def to_dict(self):
+        return {
+            '_': 'InvokeWithTakeoutRequest',
+            'takeout_id': self.takeout_id,
+            'query': self.query.to_dict() if isinstance(self.query, TLObject) else self.query
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'.\xfd\xa9\xac',
+            struct.pack('<q', self.takeout_id),
+            self.query._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _takeout_id = reader.read_long()
+        _query = reader.tgread_object()
+        return cls(takeout_id=_takeout_id, query=_query)
+
+
+class InvokeWithoutUpdatesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xbf9459b7
+    SUBCLASS_OF_ID = 0xb7b2364b
+
+    def __init__(self, query: 'TypeX'):
+        """
+        :returns X: This type has no constructors.
+        """
+        self.query = query
+
+    def to_dict(self):
+        return {
+            '_': 'InvokeWithoutUpdatesRequest',
+            'query': self.query.to_dict() if isinstance(self.query, TLObject) else self.query
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xb7Y\x94\xbf',
+            self.query._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _query = reader.tgread_object()
+        return cls(query=_query)
+
+
+class PingRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x7abe77ec
+    SUBCLASS_OF_ID = 0x816aee71
+
+    def __init__(self, ping_id: int):
+        """
+        :returns Pong: Instance of Pong.
+        """
+        self.ping_id = ping_id
+
+    def to_dict(self):
+        return {
+            '_': 'PingRequest',
+            'ping_id': self.ping_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xecw\xbez',
+            struct.pack('<q', self.ping_id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _ping_id = reader.read_long()
+        return cls(ping_id=_ping_id)
+
+
+class PingDelayDisconnectRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf3427b8c
+    SUBCLASS_OF_ID = 0x816aee71
+
+    def __init__(self, ping_id: int, disconnect_delay: int):
+        """
+        :returns Pong: Instance of Pong.
+        """
+        self.ping_id = ping_id
+        self.disconnect_delay = disconnect_delay
+
+    def to_dict(self):
+        return {
+            '_': 'PingDelayDisconnectRequest',
+            'ping_id': self.ping_id,
+            'disconnect_delay': self.disconnect_delay
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x8c{B\xf3',
+            struct.pack('<q', self.ping_id),
+            struct.pack('<i', self.disconnect_delay),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _ping_id = reader.read_long()
+        _disconnect_delay = reader.read_int()
+        return cls(ping_id=_ping_id, disconnect_delay=_disconnect_delay)
+
+
+class ReqDHParamsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xd712e4be
+    SUBCLASS_OF_ID = 0xa6188d9e
+
+    def __init__(self, nonce: int, server_nonce: int, p: bytes, q: bytes, public_key_fingerprint: int, encrypted_data: bytes):
+        """
+        :returns Server_DH_Params: Instance of either ServerDHParamsFail, ServerDHParamsOk.
+        """
+        self.nonce = nonce
+        self.server_nonce = server_nonce
+        self.p = p
+        self.q = q
+        self.public_key_fingerprint = public_key_fingerprint
+        self.encrypted_data = encrypted_data
+
+    def to_dict(self):
+        return {
+            '_': 'ReqDHParamsRequest',
+            'nonce': self.nonce,
+            'server_nonce': self.server_nonce,
+            'p': self.p,
+            'q': self.q,
+            'public_key_fingerprint': self.public_key_fingerprint,
+            'encrypted_data': self.encrypted_data
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xbe\xe4\x12\xd7',
+            self.nonce.to_bytes(16, 'little', signed=True),
+            self.server_nonce.to_bytes(16, 'little', signed=True),
+            self.serialize_bytes(self.p),
+            self.serialize_bytes(self.q),
+            struct.pack('<q', self.public_key_fingerprint),
+            self.serialize_bytes(self.encrypted_data),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _nonce = reader.read_large_int(bits=128)
+        _server_nonce = reader.read_large_int(bits=128)
+        _p = reader.tgread_bytes()
+        _q = reader.tgread_bytes()
+        _public_key_fingerprint = reader.read_long()
+        _encrypted_data = reader.tgread_bytes()
+        return cls(nonce=_nonce, server_nonce=_server_nonce, p=_p, q=_q, public_key_fingerprint=_public_key_fingerprint, encrypted_data=_encrypted_data)
+
+
+class ReqPqRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x60469778
+    SUBCLASS_OF_ID = 0x786986b8
+
+    def __init__(self, nonce: int):
+        """
+        :returns ResPQ: Instance of ResPQ.
+        """
+        self.nonce = nonce
+
+    def to_dict(self):
+        return {
+            '_': 'ReqPqRequest',
+            'nonce': self.nonce
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'x\x97F`',
+            self.nonce.to_bytes(16, 'little', signed=True),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _nonce = reader.read_large_int(bits=128)
+        return cls(nonce=_nonce)
+
+
+class ReqPqMultiRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xbe7e8ef1
+    SUBCLASS_OF_ID = 0x786986b8
+
+    def __init__(self, nonce: int):
+        """
+        :returns ResPQ: Instance of ResPQ.
+        """
+        self.nonce = nonce
+
+    def to_dict(self):
+        return {
+            '_': 'ReqPqMultiRequest',
+            'nonce': self.nonce
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xf1\x8e~\xbe',
+            self.nonce.to_bytes(16, 'little', signed=True),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _nonce = reader.read_large_int(bits=128)
+        return cls(nonce=_nonce)
+
+
+class RpcDropAnswerRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x58e4a740
+    SUBCLASS_OF_ID = 0x4bca7570
+
+    def __init__(self, req_msg_id: int):
+        """
+        :returns RpcDropAnswer: Instance of either RpcAnswerUnknown, RpcAnswerDroppedRunning, RpcAnswerDropped.
+        """
+        self.req_msg_id = req_msg_id
+
+    def to_dict(self):
+        return {
+            '_': 'RpcDropAnswerRequest',
+            'req_msg_id': self.req_msg_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'@\xa7\xe4X',
+            struct.pack('<q', self.req_msg_id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _req_msg_id = reader.read_long()
+        return cls(req_msg_id=_req_msg_id)
+
+
+class SetClientDHParamsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf5045f1f
+    SUBCLASS_OF_ID = 0x55dd6cdb
+
+    def __init__(self, nonce: int, server_nonce: int, encrypted_data: bytes):
+        """
+        :returns Set_client_DH_params_answer: Instance of either DhGenOk, DhGenRetry, DhGenFail.
+        """
+        self.nonce = nonce
+        self.server_nonce = server_nonce
+        self.encrypted_data = encrypted_data
+
+    def to_dict(self):
+        return {
+            '_': 'SetClientDHParamsRequest',
+            'nonce': self.nonce,
+            'server_nonce': self.server_nonce,
+            'encrypted_data': self.encrypted_data
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x1f_\x04\xf5',
+            self.nonce.to_bytes(16, 'little', signed=True),
+            self.server_nonce.to_bytes(16, 'little', signed=True),
+            self.serialize_bytes(self.encrypted_data),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _nonce = reader.read_large_int(bits=128)
+        _server_nonce = reader.read_large_int(bits=128)
+        _encrypted_data = reader.tgread_bytes()
+        return cls(nonce=_nonce, server_nonce=_server_nonce, encrypted_data=_encrypted_data)
+

.venv2/Lib/site-packages/telethon/tl/functions/auth.py

@@ -0,0 +1,749 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeCodeSettings, TypeEmailVerification, TypeInputCheckPasswordSRP
+    from ...tl.types.account import TypePasswordInputSettings
+
+
+
+class AcceptLoginTokenRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xe894ad4d
+    SUBCLASS_OF_ID = 0xc913c01a
+
+    def __init__(self, token: bytes):
+        """
+        :returns Authorization: Instance of Authorization.
+        """
+        self.token = token
+
+    def to_dict(self):
+        return {
+            '_': 'AcceptLoginTokenRequest',
+            'token': self.token
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'M\xad\x94\xe8',
+            self.serialize_bytes(self.token),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _token = reader.tgread_bytes()
+        return cls(token=_token)
+
+
+class BindTempAuthKeyRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xcdd42a05
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, perm_auth_key_id: int, nonce: int, expires_at: Optional[datetime], encrypted_message: bytes):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.perm_auth_key_id = perm_auth_key_id
+        self.nonce = nonce
+        self.expires_at = expires_at
+        self.encrypted_message = encrypted_message
+
+    def to_dict(self):
+        return {
+            '_': 'BindTempAuthKeyRequest',
+            'perm_auth_key_id': self.perm_auth_key_id,
+            'nonce': self.nonce,
+            'expires_at': self.expires_at,
+            'encrypted_message': self.encrypted_message
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x05*\xd4\xcd',
+            struct.pack('<q', self.perm_auth_key_id),
+            struct.pack('<q', self.nonce),
+            self.serialize_datetime(self.expires_at),
+            self.serialize_bytes(self.encrypted_message),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _perm_auth_key_id = reader.read_long()
+        _nonce = reader.read_long()
+        _expires_at = reader.tgread_date()
+        _encrypted_message = reader.tgread_bytes()
+        return cls(perm_auth_key_id=_perm_auth_key_id, nonce=_nonce, expires_at=_expires_at, encrypted_message=_encrypted_message)
+
+
+class CancelCodeRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x1f040578
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, phone_number: str, phone_code_hash: str):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.phone_number = phone_number
+        self.phone_code_hash = phone_code_hash
+
+    def to_dict(self):
+        return {
+            '_': 'CancelCodeRequest',
+            'phone_number': self.phone_number,
+            'phone_code_hash': self.phone_code_hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'x\x05\x04\x1f',
+            self.serialize_bytes(self.phone_number),
+            self.serialize_bytes(self.phone_code_hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _phone_number = reader.tgread_string()
+        _phone_code_hash = reader.tgread_string()
+        return cls(phone_number=_phone_number, phone_code_hash=_phone_code_hash)
+
+
+class CheckPasswordRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xd18b4d16
+    SUBCLASS_OF_ID = 0xb9e04e39
+
+    def __init__(self, password: 'TypeInputCheckPasswordSRP'):
+        """
+        :returns auth.Authorization: Instance of either Authorization, AuthorizationSignUpRequired.
+        """
+        self.password = password
+
+    def to_dict(self):
+        return {
+            '_': 'CheckPasswordRequest',
+            'password': self.password.to_dict() if isinstance(self.password, TLObject) else self.password
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x16M\x8b\xd1',
+            self.password._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _password = reader.tgread_object()
+        return cls(password=_password)
+
+
+class CheckRecoveryPasswordRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xd36bf79
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, code: str):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.code = code
+
+    def to_dict(self):
+        return {
+            '_': 'CheckRecoveryPasswordRequest',
+            'code': self.code
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'y\xbf6\r',
+            self.serialize_bytes(self.code),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _code = reader.tgread_string()
+        return cls(code=_code)
+
+
+class DropTempAuthKeysRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x8e48a188
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, except_auth_keys: List[int]):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.except_auth_keys = except_auth_keys
+
+    def to_dict(self):
+        return {
+            '_': 'DropTempAuthKeysRequest',
+            'except_auth_keys': [] if self.except_auth_keys is None else self.except_auth_keys[:]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x88\xa1H\x8e',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.except_auth_keys)),b''.join(struct.pack('<q', x) for x in self.except_auth_keys),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _except_auth_keys = []
+        for _ in range(reader.read_int()):
+            _x = reader.read_long()
+            _except_auth_keys.append(_x)
+
+        return cls(except_auth_keys=_except_auth_keys)
+
+
+class ExportAuthorizationRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xe5bfffcd
+    SUBCLASS_OF_ID = 0x5fd1ec51
+
+    def __init__(self, dc_id: int):
+        """
+        :returns auth.ExportedAuthorization: Instance of ExportedAuthorization.
+        """
+        self.dc_id = dc_id
+
+    def to_dict(self):
+        return {
+            '_': 'ExportAuthorizationRequest',
+            'dc_id': self.dc_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xcd\xff\xbf\xe5',
+            struct.pack('<i', self.dc_id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _dc_id = reader.read_int()
+        return cls(dc_id=_dc_id)
+
+
+class ExportLoginTokenRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xb7e085fe
+    SUBCLASS_OF_ID = 0x6b55f636
+
+    def __init__(self, api_id: int, api_hash: str, except_ids: List[int]):
+        """
+        :returns auth.LoginToken: Instance of either LoginToken, LoginTokenMigrateTo, LoginTokenSuccess.
+        """
+        self.api_id = api_id
+        self.api_hash = api_hash
+        self.except_ids = except_ids
+
+    def to_dict(self):
+        return {
+            '_': 'ExportLoginTokenRequest',
+            'api_id': self.api_id,
+            'api_hash': self.api_hash,
+            'except_ids': [] if self.except_ids is None else self.except_ids[:]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xfe\x85\xe0\xb7',
+            struct.pack('<i', self.api_id),
+            self.serialize_bytes(self.api_hash),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.except_ids)),b''.join(struct.pack('<q', x) for x in self.except_ids),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _api_id = reader.read_int()
+        _api_hash = reader.tgread_string()
+        reader.read_int()
+        _except_ids = []
+        for _ in range(reader.read_int()):
+            _x = reader.read_long()
+            _except_ids.append(_x)
+
+        return cls(api_id=_api_id, api_hash=_api_hash, except_ids=_except_ids)
+
+
+class ImportAuthorizationRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xa57a7dad
+    SUBCLASS_OF_ID = 0xb9e04e39
+
+    def __init__(self, id: int, bytes: bytes):
+        """
+        :returns auth.Authorization: Instance of either Authorization, AuthorizationSignUpRequired.
+        """
+        self.id = id
+        self.bytes = bytes
+
+    def to_dict(self):
+        return {
+            '_': 'ImportAuthorizationRequest',
+            'id': self.id,
+            'bytes': self.bytes
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xad}z\xa5',
+            struct.pack('<q', self.id),
+            self.serialize_bytes(self.bytes),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _id = reader.read_long()
+        _bytes = reader.tgread_bytes()
+        return cls(id=_id, bytes=_bytes)
+
+
+class ImportBotAuthorizationRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x67a3ff2c
+    SUBCLASS_OF_ID = 0xb9e04e39
+
+    def __init__(self, flags: int, api_id: int, api_hash: str, bot_auth_token: str):
+        """
+        :returns auth.Authorization: Instance of either Authorization, AuthorizationSignUpRequired.
+        """
+        self.flags = flags
+        self.api_id = api_id
+        self.api_hash = api_hash
+        self.bot_auth_token = bot_auth_token
+
+    def to_dict(self):
+        return {
+            '_': 'ImportBotAuthorizationRequest',
+            'flags': self.flags,
+            'api_id': self.api_id,
+            'api_hash': self.api_hash,
+            'bot_auth_token': self.bot_auth_token
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b',\xff\xa3g',
+            struct.pack('<i', self.flags),
+            struct.pack('<i', self.api_id),
+            self.serialize_bytes(self.api_hash),
+            self.serialize_bytes(self.bot_auth_token),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _flags = reader.read_int()
+        _api_id = reader.read_int()
+        _api_hash = reader.tgread_string()
+        _bot_auth_token = reader.tgread_string()
+        return cls(flags=_flags, api_id=_api_id, api_hash=_api_hash, bot_auth_token=_bot_auth_token)
+
+
+class ImportLoginTokenRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x95ac5ce4
+    SUBCLASS_OF_ID = 0x6b55f636
+
+    def __init__(self, token: bytes):
+        """
+        :returns auth.LoginToken: Instance of either LoginToken, LoginTokenMigrateTo, LoginTokenSuccess.
+        """
+        self.token = token
+
+    def to_dict(self):
+        return {
+            '_': 'ImportLoginTokenRequest',
+            'token': self.token
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xe4\\\xac\x95',
+            self.serialize_bytes(self.token),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _token = reader.tgread_bytes()
+        return cls(token=_token)
+
+
+class ImportWebTokenAuthorizationRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x2db873a9
+    SUBCLASS_OF_ID = 0xb9e04e39
+
+    def __init__(self, api_id: int, api_hash: str, web_auth_token: str):
+        """
+        :returns auth.Authorization: Instance of either Authorization, AuthorizationSignUpRequired.
+        """
+        self.api_id = api_id
+        self.api_hash = api_hash
+        self.web_auth_token = web_auth_token
+
+    def to_dict(self):
+        return {
+            '_': 'ImportWebTokenAuthorizationRequest',
+            'api_id': self.api_id,
+            'api_hash': self.api_hash,
+            'web_auth_token': self.web_auth_token
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xa9s\xb8-',
+            struct.pack('<i', self.api_id),
+            self.serialize_bytes(self.api_hash),
+            self.serialize_bytes(self.web_auth_token),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _api_id = reader.read_int()
+        _api_hash = reader.tgread_string()
+        _web_auth_token = reader.tgread_string()
+        return cls(api_id=_api_id, api_hash=_api_hash, web_auth_token=_web_auth_token)
+
+
+class LogOutRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x3e72ba19
+    SUBCLASS_OF_ID = 0xa804315
+
+    def to_dict(self):
+        return {
+            '_': 'LogOutRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x19\xbar>',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class RecoverPasswordRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x37096c70
+    SUBCLASS_OF_ID = 0xb9e04e39
+
+    def __init__(self, code: str, new_settings: Optional['TypePasswordInputSettings']=None):
+        """
+        :returns auth.Authorization: Instance of either Authorization, AuthorizationSignUpRequired.
+        """
+        self.code = code
+        self.new_settings = new_settings
+
+    def to_dict(self):
+        return {
+            '_': 'RecoverPasswordRequest',
+            'code': self.code,
+            'new_settings': self.new_settings.to_dict() if isinstance(self.new_settings, TLObject) else self.new_settings
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'pl\t7',
+            struct.pack('<I', (0 if self.new_settings is None or self.new_settings is False else 1)),
+            self.serialize_bytes(self.code),
+            b'' if self.new_settings is None or self.new_settings is False else (self.new_settings._bytes()),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _code = reader.tgread_string()
+        if flags & 1:
+            _new_settings = reader.tgread_object()
+        else:
+            _new_settings = None
+        return cls(code=_code, new_settings=_new_settings)
+
+
+class RequestFirebaseSmsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x89464b50
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, phone_number: str, phone_code_hash: str, safety_net_token: Optional[str]=None, ios_push_secret: Optional[str]=None):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.phone_number = phone_number
+        self.phone_code_hash = phone_code_hash
+        self.safety_net_token = safety_net_token
+        self.ios_push_secret = ios_push_secret
+
+    def to_dict(self):
+        return {
+            '_': 'RequestFirebaseSmsRequest',
+            'phone_number': self.phone_number,
+            'phone_code_hash': self.phone_code_hash,
+            'safety_net_token': self.safety_net_token,
+            'ios_push_secret': self.ios_push_secret
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'PKF\x89',
+            struct.pack('<I', (0 if self.safety_net_token is None or self.safety_net_token is False else 1) | (0 if self.ios_push_secret is None or self.ios_push_secret is False else 2)),
+            self.serialize_bytes(self.phone_number),
+            self.serialize_bytes(self.phone_code_hash),
+            b'' if self.safety_net_token is None or self.safety_net_token is False else (self.serialize_bytes(self.safety_net_token)),
+            b'' if self.ios_push_secret is None or self.ios_push_secret is False else (self.serialize_bytes(self.ios_push_secret)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _phone_number = reader.tgread_string()
+        _phone_code_hash = reader.tgread_string()
+        if flags & 1:
+            _safety_net_token = reader.tgread_string()
+        else:
+            _safety_net_token = None
+        if flags & 2:
+            _ios_push_secret = reader.tgread_string()
+        else:
+            _ios_push_secret = None
+        return cls(phone_number=_phone_number, phone_code_hash=_phone_code_hash, safety_net_token=_safety_net_token, ios_push_secret=_ios_push_secret)
+
+
+class RequestPasswordRecoveryRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xd897bc66
+    SUBCLASS_OF_ID = 0xfa72d43a
+
+    def to_dict(self):
+        return {
+            '_': 'RequestPasswordRecoveryRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'f\xbc\x97\xd8',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class ResendCodeRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x3ef1a9bf
+    SUBCLASS_OF_ID = 0x6ce87081
+
+    def __init__(self, phone_number: str, phone_code_hash: str):
+        """
+        :returns auth.SentCode: Instance of either SentCode, SentCodeSuccess.
+        """
+        self.phone_number = phone_number
+        self.phone_code_hash = phone_code_hash
+
+    def to_dict(self):
+        return {
+            '_': 'ResendCodeRequest',
+            'phone_number': self.phone_number,
+            'phone_code_hash': self.phone_code_hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xbf\xa9\xf1>',
+            self.serialize_bytes(self.phone_number),
+            self.serialize_bytes(self.phone_code_hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _phone_number = reader.tgread_string()
+        _phone_code_hash = reader.tgread_string()
+        return cls(phone_number=_phone_number, phone_code_hash=_phone_code_hash)
+
+
+class ResetAuthorizationsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9fab0d1a
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def to_dict(self):
+        return {
+            '_': 'ResetAuthorizationsRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x1a\r\xab\x9f',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class ResetLoginEmailRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x7e960193
+    SUBCLASS_OF_ID = 0x6ce87081
+
+    def __init__(self, phone_number: str, phone_code_hash: str):
+        """
+        :returns auth.SentCode: Instance of either SentCode, SentCodeSuccess.
+        """
+        self.phone_number = phone_number
+        self.phone_code_hash = phone_code_hash
+
+    def to_dict(self):
+        return {
+            '_': 'ResetLoginEmailRequest',
+            'phone_number': self.phone_number,
+            'phone_code_hash': self.phone_code_hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x93\x01\x96~',
+            self.serialize_bytes(self.phone_number),
+            self.serialize_bytes(self.phone_code_hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _phone_number = reader.tgread_string()
+        _phone_code_hash = reader.tgread_string()
+        return cls(phone_number=_phone_number, phone_code_hash=_phone_code_hash)
+
+
+class SendCodeRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xa677244f
+    SUBCLASS_OF_ID = 0x6ce87081
+
+    def __init__(self, phone_number: str, api_id: int, api_hash: str, settings: 'TypeCodeSettings'):
+        """
+        :returns auth.SentCode: Instance of either SentCode, SentCodeSuccess.
+        """
+        self.phone_number = phone_number
+        self.api_id = api_id
+        self.api_hash = api_hash
+        self.settings = settings
+
+    def to_dict(self):
+        return {
+            '_': 'SendCodeRequest',
+            'phone_number': self.phone_number,
+            'api_id': self.api_id,
+            'api_hash': self.api_hash,
+            'settings': self.settings.to_dict() if isinstance(self.settings, TLObject) else self.settings
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'O$w\xa6',
+            self.serialize_bytes(self.phone_number),
+            struct.pack('<i', self.api_id),
+            self.serialize_bytes(self.api_hash),
+            self.settings._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _phone_number = reader.tgread_string()
+        _api_id = reader.read_int()
+        _api_hash = reader.tgread_string()
+        _settings = reader.tgread_object()
+        return cls(phone_number=_phone_number, api_id=_api_id, api_hash=_api_hash, settings=_settings)
+
+
+class SignInRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x8d52a951
+    SUBCLASS_OF_ID = 0xb9e04e39
+
+    def __init__(self, phone_number: str, phone_code_hash: str, phone_code: Optional[str]=None, email_verification: Optional['TypeEmailVerification']=None):
+        """
+        :returns auth.Authorization: Instance of either Authorization, AuthorizationSignUpRequired.
+        """
+        self.phone_number = phone_number
+        self.phone_code_hash = phone_code_hash
+        self.phone_code = phone_code
+        self.email_verification = email_verification
+
+    def to_dict(self):
+        return {
+            '_': 'SignInRequest',
+            'phone_number': self.phone_number,
+            'phone_code_hash': self.phone_code_hash,
+            'phone_code': self.phone_code,
+            'email_verification': self.email_verification.to_dict() if isinstance(self.email_verification, TLObject) else self.email_verification
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'Q\xa9R\x8d',
+            struct.pack('<I', (0 if self.phone_code is None or self.phone_code is False else 1) | (0 if self.email_verification is None or self.email_verification is False else 2)),
+            self.serialize_bytes(self.phone_number),
+            self.serialize_bytes(self.phone_code_hash),
+            b'' if self.phone_code is None or self.phone_code is False else (self.serialize_bytes(self.phone_code)),
+            b'' if self.email_verification is None or self.email_verification is False else (self.email_verification._bytes()),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _phone_number = reader.tgread_string()
+        _phone_code_hash = reader.tgread_string()
+        if flags & 1:
+            _phone_code = reader.tgread_string()
+        else:
+            _phone_code = None
+        if flags & 2:
+            _email_verification = reader.tgread_object()
+        else:
+            _email_verification = None
+        return cls(phone_number=_phone_number, phone_code_hash=_phone_code_hash, phone_code=_phone_code, email_verification=_email_verification)
+
+
+class SignUpRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xaac7b717
+    SUBCLASS_OF_ID = 0xb9e04e39
+
+    def __init__(self, phone_number: str, phone_code_hash: str, first_name: str, last_name: str, no_joined_notifications: Optional[bool]=None):
+        """
+        :returns auth.Authorization: Instance of either Authorization, AuthorizationSignUpRequired.
+        """
+        self.phone_number = phone_number
+        self.phone_code_hash = phone_code_hash
+        self.first_name = first_name
+        self.last_name = last_name
+        self.no_joined_notifications = no_joined_notifications
+
+    def to_dict(self):
+        return {
+            '_': 'SignUpRequest',
+            'phone_number': self.phone_number,
+            'phone_code_hash': self.phone_code_hash,
+            'first_name': self.first_name,
+            'last_name': self.last_name,
+            'no_joined_notifications': self.no_joined_notifications
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x17\xb7\xc7\xaa',
+            struct.pack('<I', (0 if self.no_joined_notifications is None or self.no_joined_notifications is False else 1)),
+            self.serialize_bytes(self.phone_number),
+            self.serialize_bytes(self.phone_code_hash),
+            self.serialize_bytes(self.first_name),
+            self.serialize_bytes(self.last_name),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _no_joined_notifications = bool(flags & 1)
+        _phone_number = reader.tgread_string()
+        _phone_code_hash = reader.tgread_string()
+        _first_name = reader.tgread_string()
+        _last_name = reader.tgread_string()
+        return cls(phone_number=_phone_number, phone_code_hash=_phone_code_hash, first_name=_first_name, last_name=_last_name, no_joined_notifications=_no_joined_notifications)
+

.venv2/Lib/site-packages/telethon/tl/functions/bots.py

@@ -0,0 +1,587 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeBotCommand, TypeBotCommandScope, TypeBotMenuButton, TypeChatAdminRights, TypeDataJSON, TypeInputUser
+
+
+
+class AllowSendMessageRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf132e3ef
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, bot: 'TypeInputUser'):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.bot = bot
+
+    async def resolve(self, client, utils):
+        self.bot = utils.get_input_user(await client.get_input_entity(self.bot))
+
+    def to_dict(self):
+        return {
+            '_': 'AllowSendMessageRequest',
+            'bot': self.bot.to_dict() if isinstance(self.bot, TLObject) else self.bot
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xef\xe32\xf1',
+            self.bot._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _bot = reader.tgread_object()
+        return cls(bot=_bot)
+
+
+class AnswerWebhookJSONQueryRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xe6213f4d
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, query_id: int, data: 'TypeDataJSON'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.query_id = query_id
+        self.data = data
+
+    def to_dict(self):
+        return {
+            '_': 'AnswerWebhookJSONQueryRequest',
+            'query_id': self.query_id,
+            'data': self.data.to_dict() if isinstance(self.data, TLObject) else self.data
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'M?!\xe6',
+            struct.pack('<q', self.query_id),
+            self.data._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _query_id = reader.read_long()
+        _data = reader.tgread_object()
+        return cls(query_id=_query_id, data=_data)
+
+
+class CanSendMessageRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x1359f4e6
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, bot: 'TypeInputUser'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.bot = bot
+
+    async def resolve(self, client, utils):
+        self.bot = utils.get_input_user(await client.get_input_entity(self.bot))
+
+    def to_dict(self):
+        return {
+            '_': 'CanSendMessageRequest',
+            'bot': self.bot.to_dict() if isinstance(self.bot, TLObject) else self.bot
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xe6\xf4Y\x13',
+            self.bot._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _bot = reader.tgread_object()
+        return cls(bot=_bot)
+
+
+class GetBotCommandsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xe34c0dd6
+    SUBCLASS_OF_ID = 0xfae91529
+
+    def __init__(self, scope: 'TypeBotCommandScope', lang_code: str):
+        """
+        :returns Vector<BotCommand>: This type has no constructors.
+        """
+        self.scope = scope
+        self.lang_code = lang_code
+
+    def to_dict(self):
+        return {
+            '_': 'GetBotCommandsRequest',
+            'scope': self.scope.to_dict() if isinstance(self.scope, TLObject) else self.scope,
+            'lang_code': self.lang_code
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xd6\rL\xe3',
+            self.scope._bytes(),
+            self.serialize_bytes(self.lang_code),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _scope = reader.tgread_object()
+        _lang_code = reader.tgread_string()
+        return cls(scope=_scope, lang_code=_lang_code)
+
+
+class GetBotInfoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xdcd914fd
+    SUBCLASS_OF_ID = 0xca7b2235
+
+    def __init__(self, lang_code: str, bot: Optional['TypeInputUser']=None):
+        """
+        :returns bots.BotInfo: Instance of BotInfo.
+        """
+        self.lang_code = lang_code
+        self.bot = bot
+
+    async def resolve(self, client, utils):
+        if self.bot:
+            self.bot = utils.get_input_user(await client.get_input_entity(self.bot))
+
+    def to_dict(self):
+        return {
+            '_': 'GetBotInfoRequest',
+            'lang_code': self.lang_code,
+            'bot': self.bot.to_dict() if isinstance(self.bot, TLObject) else self.bot
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xfd\x14\xd9\xdc',
+            struct.pack('<I', (0 if self.bot is None or self.bot is False else 1)),
+            b'' if self.bot is None or self.bot is False else (self.bot._bytes()),
+            self.serialize_bytes(self.lang_code),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        if flags & 1:
+            _bot = reader.tgread_object()
+        else:
+            _bot = None
+        _lang_code = reader.tgread_string()
+        return cls(lang_code=_lang_code, bot=_bot)
+
+
+class GetBotMenuButtonRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9c60eb28
+    SUBCLASS_OF_ID = 0x4c71bd3c
+
+    def __init__(self, user_id: 'TypeInputUser'):
+        """
+        :returns BotMenuButton: Instance of either BotMenuButtonDefault, BotMenuButtonCommands, BotMenuButton.
+        """
+        self.user_id = user_id
+
+    async def resolve(self, client, utils):
+        self.user_id = utils.get_input_user(await client.get_input_entity(self.user_id))
+
+    def to_dict(self):
+        return {
+            '_': 'GetBotMenuButtonRequest',
+            'user_id': self.user_id.to_dict() if isinstance(self.user_id, TLObject) else self.user_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'(\xeb`\x9c',
+            self.user_id._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _user_id = reader.tgread_object()
+        return cls(user_id=_user_id)
+
+
+class InvokeWebViewCustomMethodRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x87fc5e7
+    SUBCLASS_OF_ID = 0xad0352e8
+
+    def __init__(self, bot: 'TypeInputUser', custom_method: str, params: 'TypeDataJSON'):
+        """
+        :returns DataJSON: Instance of DataJSON.
+        """
+        self.bot = bot
+        self.custom_method = custom_method
+        self.params = params
+
+    async def resolve(self, client, utils):
+        self.bot = utils.get_input_user(await client.get_input_entity(self.bot))
+
+    def to_dict(self):
+        return {
+            '_': 'InvokeWebViewCustomMethodRequest',
+            'bot': self.bot.to_dict() if isinstance(self.bot, TLObject) else self.bot,
+            'custom_method': self.custom_method,
+            'params': self.params.to_dict() if isinstance(self.params, TLObject) else self.params
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xe7\xc5\x7f\x08',
+            self.bot._bytes(),
+            self.serialize_bytes(self.custom_method),
+            self.params._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _bot = reader.tgread_object()
+        _custom_method = reader.tgread_string()
+        _params = reader.tgread_object()
+        return cls(bot=_bot, custom_method=_custom_method, params=_params)
+
+
+class ReorderUsernamesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9709b1c2
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, bot: 'TypeInputUser', order: List[str]):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.bot = bot
+        self.order = order
+
+    async def resolve(self, client, utils):
+        self.bot = utils.get_input_user(await client.get_input_entity(self.bot))
+
+    def to_dict(self):
+        return {
+            '_': 'ReorderUsernamesRequest',
+            'bot': self.bot.to_dict() if isinstance(self.bot, TLObject) else self.bot,
+            'order': [] if self.order is None else self.order[:]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xc2\xb1\t\x97',
+            self.bot._bytes(),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.order)),b''.join(self.serialize_bytes(x) for x in self.order),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _bot = reader.tgread_object()
+        reader.read_int()
+        _order = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_string()
+            _order.append(_x)
+
+        return cls(bot=_bot, order=_order)
+
+
+class ResetBotCommandsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x3d8de0f9
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, scope: 'TypeBotCommandScope', lang_code: str):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.scope = scope
+        self.lang_code = lang_code
+
+    def to_dict(self):
+        return {
+            '_': 'ResetBotCommandsRequest',
+            'scope': self.scope.to_dict() if isinstance(self.scope, TLObject) else self.scope,
+            'lang_code': self.lang_code
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xf9\xe0\x8d=',
+            self.scope._bytes(),
+            self.serialize_bytes(self.lang_code),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _scope = reader.tgread_object()
+        _lang_code = reader.tgread_string()
+        return cls(scope=_scope, lang_code=_lang_code)
+
+
+class SendCustomRequestRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xaa2769ed
+    SUBCLASS_OF_ID = 0xad0352e8
+
+    def __init__(self, custom_method: str, params: 'TypeDataJSON'):
+        """
+        :returns DataJSON: Instance of DataJSON.
+        """
+        self.custom_method = custom_method
+        self.params = params
+
+    def to_dict(self):
+        return {
+            '_': 'SendCustomRequestRequest',
+            'custom_method': self.custom_method,
+            'params': self.params.to_dict() if isinstance(self.params, TLObject) else self.params
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b"\xedi'\xaa",
+            self.serialize_bytes(self.custom_method),
+            self.params._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _custom_method = reader.tgread_string()
+        _params = reader.tgread_object()
+        return cls(custom_method=_custom_method, params=_params)
+
+
+class SetBotBroadcastDefaultAdminRightsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x788464e1
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, admin_rights: 'TypeChatAdminRights'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.admin_rights = admin_rights
+
+    def to_dict(self):
+        return {
+            '_': 'SetBotBroadcastDefaultAdminRightsRequest',
+            'admin_rights': self.admin_rights.to_dict() if isinstance(self.admin_rights, TLObject) else self.admin_rights
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xe1d\x84x',
+            self.admin_rights._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _admin_rights = reader.tgread_object()
+        return cls(admin_rights=_admin_rights)
+
+
+class SetBotCommandsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x517165a
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, scope: 'TypeBotCommandScope', lang_code: str, commands: List['TypeBotCommand']):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.scope = scope
+        self.lang_code = lang_code
+        self.commands = commands
+
+    def to_dict(self):
+        return {
+            '_': 'SetBotCommandsRequest',
+            'scope': self.scope.to_dict() if isinstance(self.scope, TLObject) else self.scope,
+            'lang_code': self.lang_code,
+            'commands': [] if self.commands is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.commands]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'Z\x16\x17\x05',
+            self.scope._bytes(),
+            self.serialize_bytes(self.lang_code),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.commands)),b''.join(x._bytes() for x in self.commands),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _scope = reader.tgread_object()
+        _lang_code = reader.tgread_string()
+        reader.read_int()
+        _commands = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _commands.append(_x)
+
+        return cls(scope=_scope, lang_code=_lang_code, commands=_commands)
+
+
+class SetBotGroupDefaultAdminRightsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x925ec9ea
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, admin_rights: 'TypeChatAdminRights'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.admin_rights = admin_rights
+
+    def to_dict(self):
+        return {
+            '_': 'SetBotGroupDefaultAdminRightsRequest',
+            'admin_rights': self.admin_rights.to_dict() if isinstance(self.admin_rights, TLObject) else self.admin_rights
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xea\xc9^\x92',
+            self.admin_rights._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _admin_rights = reader.tgread_object()
+        return cls(admin_rights=_admin_rights)
+
+
+class SetBotInfoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x10cf3123
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, lang_code: str, bot: Optional['TypeInputUser']=None, name: Optional[str]=None, about: Optional[str]=None, description: Optional[str]=None):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.lang_code = lang_code
+        self.bot = bot
+        self.name = name
+        self.about = about
+        self.description = description
+
+    async def resolve(self, client, utils):
+        if self.bot:
+            self.bot = utils.get_input_user(await client.get_input_entity(self.bot))
+
+    def to_dict(self):
+        return {
+            '_': 'SetBotInfoRequest',
+            'lang_code': self.lang_code,
+            'bot': self.bot.to_dict() if isinstance(self.bot, TLObject) else self.bot,
+            'name': self.name,
+            'about': self.about,
+            'description': self.description
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'#1\xcf\x10',
+            struct.pack('<I', (0 if self.bot is None or self.bot is False else 4) | (0 if self.name is None or self.name is False else 8) | (0 if self.about is None or self.about is False else 1) | (0 if self.description is None or self.description is False else 2)),
+            b'' if self.bot is None or self.bot is False else (self.bot._bytes()),
+            self.serialize_bytes(self.lang_code),
+            b'' if self.name is None or self.name is False else (self.serialize_bytes(self.name)),
+            b'' if self.about is None or self.about is False else (self.serialize_bytes(self.about)),
+            b'' if self.description is None or self.description is False else (self.serialize_bytes(self.description)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        if flags & 4:
+            _bot = reader.tgread_object()
+        else:
+            _bot = None
+        _lang_code = reader.tgread_string()
+        if flags & 8:
+            _name = reader.tgread_string()
+        else:
+            _name = None
+        if flags & 1:
+            _about = reader.tgread_string()
+        else:
+            _about = None
+        if flags & 2:
+            _description = reader.tgread_string()
+        else:
+            _description = None
+        return cls(lang_code=_lang_code, bot=_bot, name=_name, about=_about, description=_description)
+
+
+class SetBotMenuButtonRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x4504d54f
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, user_id: 'TypeInputUser', button: 'TypeBotMenuButton'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.user_id = user_id
+        self.button = button
+
+    async def resolve(self, client, utils):
+        self.user_id = utils.get_input_user(await client.get_input_entity(self.user_id))
+
+    def to_dict(self):
+        return {
+            '_': 'SetBotMenuButtonRequest',
+            'user_id': self.user_id.to_dict() if isinstance(self.user_id, TLObject) else self.user_id,
+            'button': self.button.to_dict() if isinstance(self.button, TLObject) else self.button
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'O\xd5\x04E',
+            self.user_id._bytes(),
+            self.button._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _user_id = reader.tgread_object()
+        _button = reader.tgread_object()
+        return cls(user_id=_user_id, button=_button)
+
+
+class ToggleUsernameRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x53ca973
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, bot: 'TypeInputUser', username: str, active: bool):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.bot = bot
+        self.username = username
+        self.active = active
+
+    async def resolve(self, client, utils):
+        self.bot = utils.get_input_user(await client.get_input_entity(self.bot))
+
+    def to_dict(self):
+        return {
+            '_': 'ToggleUsernameRequest',
+            'bot': self.bot.to_dict() if isinstance(self.bot, TLObject) else self.bot,
+            'username': self.username,
+            'active': self.active
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b's\xa9<\x05',
+            self.bot._bytes(),
+            self.serialize_bytes(self.username),
+            b'\xb5ur\x99' if self.active else b'7\x97y\xbc',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _bot = reader.tgread_object()
+        _username = reader.tgread_string()
+        _active = reader.tgread_bool()
+        return cls(bot=_bot, username=_username, active=_active)
+

.venv2/Lib/site-packages/telethon/tl/functions/chatlists.py

@@ -0,0 +1,425 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputChatlist, TypeInputPeer
+
+
+
+class CheckChatlistInviteRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x41c10fff
+    SUBCLASS_OF_ID = 0x41720e75
+
+    def __init__(self, slug: str):
+        """
+        :returns chatlists.ChatlistInvite: Instance of either ChatlistInviteAlready, ChatlistInvite.
+        """
+        self.slug = slug
+
+    def to_dict(self):
+        return {
+            '_': 'CheckChatlistInviteRequest',
+            'slug': self.slug
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xff\x0f\xc1A',
+            self.serialize_bytes(self.slug),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _slug = reader.tgread_string()
+        return cls(slug=_slug)
+
+
+class DeleteExportedInviteRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x719c5c5e
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, chatlist: 'TypeInputChatlist', slug: str):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.chatlist = chatlist
+        self.slug = slug
+
+    def to_dict(self):
+        return {
+            '_': 'DeleteExportedInviteRequest',
+            'chatlist': self.chatlist.to_dict() if isinstance(self.chatlist, TLObject) else self.chatlist,
+            'slug': self.slug
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'^\\\x9cq',
+            self.chatlist._bytes(),
+            self.serialize_bytes(self.slug),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _chatlist = reader.tgread_object()
+        _slug = reader.tgread_string()
+        return cls(chatlist=_chatlist, slug=_slug)
+
+
+class EditExportedInviteRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x653db63d
+    SUBCLASS_OF_ID = 0x7711f8ff
+
+    def __init__(self, chatlist: 'TypeInputChatlist', slug: str, title: Optional[str]=None, peers: Optional[List['TypeInputPeer']]=None):
+        """
+        :returns ExportedChatlistInvite: Instance of ExportedChatlistInvite.
+        """
+        self.chatlist = chatlist
+        self.slug = slug
+        self.title = title
+        self.peers = peers
+
+    async def resolve(self, client, utils):
+        if self.peers:
+            _tmp = []
+            for _x in self.peers:
+                _tmp.append(utils.get_input_peer(await client.get_input_entity(_x)))
+
+            self.peers = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'EditExportedInviteRequest',
+            'chatlist': self.chatlist.to_dict() if isinstance(self.chatlist, TLObject) else self.chatlist,
+            'slug': self.slug,
+            'title': self.title,
+            'peers': [] if self.peers is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.peers]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'=\xb6=e',
+            struct.pack('<I', (0 if self.title is None or self.title is False else 2) | (0 if self.peers is None or self.peers is False else 4)),
+            self.chatlist._bytes(),
+            self.serialize_bytes(self.slug),
+            b'' if self.title is None or self.title is False else (self.serialize_bytes(self.title)),
+            b'' if self.peers is None or self.peers is False else b''.join((b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.peers)),b''.join(x._bytes() for x in self.peers))),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _chatlist = reader.tgread_object()
+        _slug = reader.tgread_string()
+        if flags & 2:
+            _title = reader.tgread_string()
+        else:
+            _title = None
+        if flags & 4:
+            reader.read_int()
+            _peers = []
+            for _ in range(reader.read_int()):
+                _x = reader.tgread_object()
+                _peers.append(_x)
+
+        else:
+            _peers = None
+        return cls(chatlist=_chatlist, slug=_slug, title=_title, peers=_peers)
+
+
+class ExportChatlistInviteRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x8472478e
+    SUBCLASS_OF_ID = 0xc2694ee9
+
+    def __init__(self, chatlist: 'TypeInputChatlist', title: str, peers: List['TypeInputPeer']):
+        """
+        :returns chatlists.ExportedChatlistInvite: Instance of ExportedChatlistInvite.
+        """
+        self.chatlist = chatlist
+        self.title = title
+        self.peers = peers
+
+    async def resolve(self, client, utils):
+        _tmp = []
+        for _x in self.peers:
+            _tmp.append(utils.get_input_peer(await client.get_input_entity(_x)))
+
+        self.peers = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'ExportChatlistInviteRequest',
+            'chatlist': self.chatlist.to_dict() if isinstance(self.chatlist, TLObject) else self.chatlist,
+            'title': self.title,
+            'peers': [] if self.peers is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.peers]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x8eGr\x84',
+            self.chatlist._bytes(),
+            self.serialize_bytes(self.title),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.peers)),b''.join(x._bytes() for x in self.peers),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _chatlist = reader.tgread_object()
+        _title = reader.tgread_string()
+        reader.read_int()
+        _peers = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _peers.append(_x)
+
+        return cls(chatlist=_chatlist, title=_title, peers=_peers)
+
+
+class GetChatlistUpdatesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x89419521
+    SUBCLASS_OF_ID = 0x7d1641ea
+
+    def __init__(self, chatlist: 'TypeInputChatlist'):
+        """
+        :returns chatlists.ChatlistUpdates: Instance of ChatlistUpdates.
+        """
+        self.chatlist = chatlist
+
+    def to_dict(self):
+        return {
+            '_': 'GetChatlistUpdatesRequest',
+            'chatlist': self.chatlist.to_dict() if isinstance(self.chatlist, TLObject) else self.chatlist
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'!\x95A\x89',
+            self.chatlist._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _chatlist = reader.tgread_object()
+        return cls(chatlist=_chatlist)
+
+
+class GetExportedInvitesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xce03da83
+    SUBCLASS_OF_ID = 0xe6c209c0
+
+    def __init__(self, chatlist: 'TypeInputChatlist'):
+        """
+        :returns chatlists.ExportedInvites: Instance of ExportedInvites.
+        """
+        self.chatlist = chatlist
+
+    def to_dict(self):
+        return {
+            '_': 'GetExportedInvitesRequest',
+            'chatlist': self.chatlist.to_dict() if isinstance(self.chatlist, TLObject) else self.chatlist
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x83\xda\x03\xce',
+            self.chatlist._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _chatlist = reader.tgread_object()
+        return cls(chatlist=_chatlist)
+
+
+class GetLeaveChatlistSuggestionsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xfdbcd714
+    SUBCLASS_OF_ID = 0xb9945d7e
+
+    def __init__(self, chatlist: 'TypeInputChatlist'):
+        """
+        :returns Vector<Peer>: This type has no constructors.
+        """
+        self.chatlist = chatlist
+
+    def to_dict(self):
+        return {
+            '_': 'GetLeaveChatlistSuggestionsRequest',
+            'chatlist': self.chatlist.to_dict() if isinstance(self.chatlist, TLObject) else self.chatlist
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x14\xd7\xbc\xfd',
+            self.chatlist._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _chatlist = reader.tgread_object()
+        return cls(chatlist=_chatlist)
+
+
+class HideChatlistUpdatesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x66e486fb
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, chatlist: 'TypeInputChatlist'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.chatlist = chatlist
+
+    def to_dict(self):
+        return {
+            '_': 'HideChatlistUpdatesRequest',
+            'chatlist': self.chatlist.to_dict() if isinstance(self.chatlist, TLObject) else self.chatlist
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xfb\x86\xe4f',
+            self.chatlist._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _chatlist = reader.tgread_object()
+        return cls(chatlist=_chatlist)
+
+
+class JoinChatlistInviteRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xa6b1e39a
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, slug: str, peers: List['TypeInputPeer']):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.slug = slug
+        self.peers = peers
+
+    async def resolve(self, client, utils):
+        _tmp = []
+        for _x in self.peers:
+            _tmp.append(utils.get_input_peer(await client.get_input_entity(_x)))
+
+        self.peers = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'JoinChatlistInviteRequest',
+            'slug': self.slug,
+            'peers': [] if self.peers is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.peers]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x9a\xe3\xb1\xa6',
+            self.serialize_bytes(self.slug),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.peers)),b''.join(x._bytes() for x in self.peers),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _slug = reader.tgread_string()
+        reader.read_int()
+        _peers = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _peers.append(_x)
+
+        return cls(slug=_slug, peers=_peers)
+
+
+class JoinChatlistUpdatesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xe089f8f5
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, chatlist: 'TypeInputChatlist', peers: List['TypeInputPeer']):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.chatlist = chatlist
+        self.peers = peers
+
+    async def resolve(self, client, utils):
+        _tmp = []
+        for _x in self.peers:
+            _tmp.append(utils.get_input_peer(await client.get_input_entity(_x)))
+
+        self.peers = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'JoinChatlistUpdatesRequest',
+            'chatlist': self.chatlist.to_dict() if isinstance(self.chatlist, TLObject) else self.chatlist,
+            'peers': [] if self.peers is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.peers]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xf5\xf8\x89\xe0',
+            self.chatlist._bytes(),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.peers)),b''.join(x._bytes() for x in self.peers),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _chatlist = reader.tgread_object()
+        reader.read_int()
+        _peers = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _peers.append(_x)
+
+        return cls(chatlist=_chatlist, peers=_peers)
+
+
+class LeaveChatlistRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x74fae13a
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, chatlist: 'TypeInputChatlist', peers: List['TypeInputPeer']):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.chatlist = chatlist
+        self.peers = peers
+
+    async def resolve(self, client, utils):
+        _tmp = []
+        for _x in self.peers:
+            _tmp.append(utils.get_input_peer(await client.get_input_entity(_x)))
+
+        self.peers = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'LeaveChatlistRequest',
+            'chatlist': self.chatlist.to_dict() if isinstance(self.chatlist, TLObject) else self.chatlist,
+            'peers': [] if self.peers is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.peers]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b':\xe1\xfat',
+            self.chatlist._bytes(),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.peers)),b''.join(x._bytes() for x in self.peers),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _chatlist = reader.tgread_object()
+        reader.read_int()
+        _peers = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _peers.append(_x)
+
+        return cls(chatlist=_chatlist, peers=_peers)
+

.venv2/Lib/site-packages/telethon/tl/functions/contacts.py

@@ -0,0 +1,852 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputContact, TypeInputGeoPoint, TypeInputPeer, TypeInputUser, TypeTopPeerCategory
+
+
+
+class AcceptContactRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf831a20f
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, id: 'TypeInputUser'):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.id = id
+
+    async def resolve(self, client, utils):
+        self.id = utils.get_input_user(await client.get_input_entity(self.id))
+
+    def to_dict(self):
+        return {
+            '_': 'AcceptContactRequest',
+            'id': self.id.to_dict() if isinstance(self.id, TLObject) else self.id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x0f\xa21\xf8',
+            self.id._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _id = reader.tgread_object()
+        return cls(id=_id)
+
+
+class AddContactRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xe8f463d0
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, id: 'TypeInputUser', first_name: str, last_name: str, phone: str, add_phone_privacy_exception: Optional[bool]=None):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.id = id
+        self.first_name = first_name
+        self.last_name = last_name
+        self.phone = phone
+        self.add_phone_privacy_exception = add_phone_privacy_exception
+
+    async def resolve(self, client, utils):
+        self.id = utils.get_input_user(await client.get_input_entity(self.id))
+
+    def to_dict(self):
+        return {
+            '_': 'AddContactRequest',
+            'id': self.id.to_dict() if isinstance(self.id, TLObject) else self.id,
+            'first_name': self.first_name,
+            'last_name': self.last_name,
+            'phone': self.phone,
+            'add_phone_privacy_exception': self.add_phone_privacy_exception
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xd0c\xf4\xe8',
+            struct.pack('<I', (0 if self.add_phone_privacy_exception is None or self.add_phone_privacy_exception is False else 1)),
+            self.id._bytes(),
+            self.serialize_bytes(self.first_name),
+            self.serialize_bytes(self.last_name),
+            self.serialize_bytes(self.phone),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _add_phone_privacy_exception = bool(flags & 1)
+        _id = reader.tgread_object()
+        _first_name = reader.tgread_string()
+        _last_name = reader.tgread_string()
+        _phone = reader.tgread_string()
+        return cls(id=_id, first_name=_first_name, last_name=_last_name, phone=_phone, add_phone_privacy_exception=_add_phone_privacy_exception)
+
+
+class BlockRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x2e2e8734
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, id: 'TypeInputPeer', my_stories_from: Optional[bool]=None):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.id = id
+        self.my_stories_from = my_stories_from
+
+    async def resolve(self, client, utils):
+        self.id = utils.get_input_peer(await client.get_input_entity(self.id))
+
+    def to_dict(self):
+        return {
+            '_': 'BlockRequest',
+            'id': self.id.to_dict() if isinstance(self.id, TLObject) else self.id,
+            'my_stories_from': self.my_stories_from
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'4\x87..',
+            struct.pack('<I', (0 if self.my_stories_from is None or self.my_stories_from is False else 1)),
+            self.id._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _my_stories_from = bool(flags & 1)
+        _id = reader.tgread_object()
+        return cls(id=_id, my_stories_from=_my_stories_from)
+
+
+class BlockFromRepliesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x29a8962c
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, msg_id: int, delete_message: Optional[bool]=None, delete_history: Optional[bool]=None, report_spam: Optional[bool]=None):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.msg_id = msg_id
+        self.delete_message = delete_message
+        self.delete_history = delete_history
+        self.report_spam = report_spam
+
+    def to_dict(self):
+        return {
+            '_': 'BlockFromRepliesRequest',
+            'msg_id': self.msg_id,
+            'delete_message': self.delete_message,
+            'delete_history': self.delete_history,
+            'report_spam': self.report_spam
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b',\x96\xa8)',
+            struct.pack('<I', (0 if self.delete_message is None or self.delete_message is False else 1) | (0 if self.delete_history is None or self.delete_history is False else 2) | (0 if self.report_spam is None or self.report_spam is False else 4)),
+            struct.pack('<i', self.msg_id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _delete_message = bool(flags & 1)
+        _delete_history = bool(flags & 2)
+        _report_spam = bool(flags & 4)
+        _msg_id = reader.read_int()
+        return cls(msg_id=_msg_id, delete_message=_delete_message, delete_history=_delete_history, report_spam=_report_spam)
+
+
+class DeleteByPhonesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x1013fd9e
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, phones: List[str]):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.phones = phones
+
+    def to_dict(self):
+        return {
+            '_': 'DeleteByPhonesRequest',
+            'phones': [] if self.phones is None else self.phones[:]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x9e\xfd\x13\x10',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.phones)),b''.join(self.serialize_bytes(x) for x in self.phones),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _phones = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_string()
+            _phones.append(_x)
+
+        return cls(phones=_phones)
+
+
+class DeleteContactsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x96a0e00
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, id: List['TypeInputUser']):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.id = id
+
+    async def resolve(self, client, utils):
+        _tmp = []
+        for _x in self.id:
+            _tmp.append(utils.get_input_user(await client.get_input_entity(_x)))
+
+        self.id = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'DeleteContactsRequest',
+            'id': [] if self.id is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.id]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x00\x0ej\t',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.id)),b''.join(x._bytes() for x in self.id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _id = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _id.append(_x)
+
+        return cls(id=_id)
+
+
+class EditCloseFriendsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xba6705f0
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, id: List[int]):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.id = id
+
+    def to_dict(self):
+        return {
+            '_': 'EditCloseFriendsRequest',
+            'id': [] if self.id is None else self.id[:]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xf0\x05g\xba',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.id)),b''.join(struct.pack('<q', x) for x in self.id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _id = []
+        for _ in range(reader.read_int()):
+            _x = reader.read_long()
+            _id.append(_x)
+
+        return cls(id=_id)
+
+
+class ExportContactTokenRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf8654027
+    SUBCLASS_OF_ID = 0x86ddbed1
+
+    def to_dict(self):
+        return {
+            '_': 'ExportContactTokenRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b"'@e\xf8",
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetBlockedRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9a868f80
+    SUBCLASS_OF_ID = 0xffba4f4f
+
+    def __init__(self, offset: int, limit: int, my_stories_from: Optional[bool]=None):
+        """
+        :returns contacts.Blocked: Instance of either Blocked, BlockedSlice.
+        """
+        self.offset = offset
+        self.limit = limit
+        self.my_stories_from = my_stories_from
+
+    def to_dict(self):
+        return {
+            '_': 'GetBlockedRequest',
+            'offset': self.offset,
+            'limit': self.limit,
+            'my_stories_from': self.my_stories_from
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x80\x8f\x86\x9a',
+            struct.pack('<I', (0 if self.my_stories_from is None or self.my_stories_from is False else 1)),
+            struct.pack('<i', self.offset),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _my_stories_from = bool(flags & 1)
+        _offset = reader.read_int()
+        _limit = reader.read_int()
+        return cls(offset=_offset, limit=_limit, my_stories_from=_my_stories_from)
+
+
+class GetContactIDsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x7adc669d
+    SUBCLASS_OF_ID = 0x5026710f
+
+    def __init__(self, hash: int):
+        """
+        :returns Vector<int>: This type has no constructors.
+        """
+        self.hash = hash
+
+    def to_dict(self):
+        return {
+            '_': 'GetContactIDsRequest',
+            'hash': self.hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x9df\xdcz',
+            struct.pack('<q', self.hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _hash = reader.read_long()
+        return cls(hash=_hash)
+
+    @staticmethod
+    def read_result(reader):
+        reader.read_int()  # Vector ID
+        return [reader.read_int() for _ in range(reader.read_int())]
+
+
+class GetContactsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x5dd69e12
+    SUBCLASS_OF_ID = 0x38be25f6
+
+    def __init__(self, hash: int):
+        """
+        :returns contacts.Contacts: Instance of either ContactsNotModified, Contacts.
+        """
+        self.hash = hash
+
+    def to_dict(self):
+        return {
+            '_': 'GetContactsRequest',
+            'hash': self.hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x12\x9e\xd6]',
+            struct.pack('<q', self.hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _hash = reader.read_long()
+        return cls(hash=_hash)
+
+
+class GetLocatedRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xd348bc44
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, geo_point: 'TypeInputGeoPoint', background: Optional[bool]=None, self_expires: Optional[int]=None):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.geo_point = geo_point
+        self.background = background
+        self.self_expires = self_expires
+
+    def to_dict(self):
+        return {
+            '_': 'GetLocatedRequest',
+            'geo_point': self.geo_point.to_dict() if isinstance(self.geo_point, TLObject) else self.geo_point,
+            'background': self.background,
+            'self_expires': self.self_expires
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'D\xbcH\xd3',
+            struct.pack('<I', (0 if self.background is None or self.background is False else 2) | (0 if self.self_expires is None or self.self_expires is False else 1)),
+            self.geo_point._bytes(),
+            b'' if self.self_expires is None or self.self_expires is False else (struct.pack('<i', self.self_expires)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _background = bool(flags & 2)
+        _geo_point = reader.tgread_object()
+        if flags & 1:
+            _self_expires = reader.read_int()
+        else:
+            _self_expires = None
+        return cls(geo_point=_geo_point, background=_background, self_expires=_self_expires)
+
+
+class GetSavedRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x82f1e39f
+    SUBCLASS_OF_ID = 0x975dbef
+
+    def to_dict(self):
+        return {
+            '_': 'GetSavedRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x9f\xe3\xf1\x82',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetStatusesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xc4a353ee
+    SUBCLASS_OF_ID = 0xdf815c90
+
+    def to_dict(self):
+        return {
+            '_': 'GetStatusesRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xeeS\xa3\xc4',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetTopPeersRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x973478b6
+    SUBCLASS_OF_ID = 0x9ee8bb88
+
+    def __init__(self, offset: int, limit: int, hash: int, correspondents: Optional[bool]=None, bots_pm: Optional[bool]=None, bots_inline: Optional[bool]=None, phone_calls: Optional[bool]=None, forward_users: Optional[bool]=None, forward_chats: Optional[bool]=None, groups: Optional[bool]=None, channels: Optional[bool]=None):
+        """
+        :returns contacts.TopPeers: Instance of either TopPeersNotModified, TopPeers, TopPeersDisabled.
+        """
+        self.offset = offset
+        self.limit = limit
+        self.hash = hash
+        self.correspondents = correspondents
+        self.bots_pm = bots_pm
+        self.bots_inline = bots_inline
+        self.phone_calls = phone_calls
+        self.forward_users = forward_users
+        self.forward_chats = forward_chats
+        self.groups = groups
+        self.channels = channels
+
+    def to_dict(self):
+        return {
+            '_': 'GetTopPeersRequest',
+            'offset': self.offset,
+            'limit': self.limit,
+            'hash': self.hash,
+            'correspondents': self.correspondents,
+            'bots_pm': self.bots_pm,
+            'bots_inline': self.bots_inline,
+            'phone_calls': self.phone_calls,
+            'forward_users': self.forward_users,
+            'forward_chats': self.forward_chats,
+            'groups': self.groups,
+            'channels': self.channels
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xb6x4\x97',
+            struct.pack('<I', (0 if self.correspondents is None or self.correspondents is False else 1) | (0 if self.bots_pm is None or self.bots_pm is False else 2) | (0 if self.bots_inline is None or self.bots_inline is False else 4) | (0 if self.phone_calls is None or self.phone_calls is False else 8) | (0 if self.forward_users is None or self.forward_users is False else 16) | (0 if self.forward_chats is None or self.forward_chats is False else 32) | (0 if self.groups is None or self.groups is False else 1024) | (0 if self.channels is None or self.channels is False else 32768)),
+            struct.pack('<i', self.offset),
+            struct.pack('<i', self.limit),
+            struct.pack('<q', self.hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _correspondents = bool(flags & 1)
+        _bots_pm = bool(flags & 2)
+        _bots_inline = bool(flags & 4)
+        _phone_calls = bool(flags & 8)
+        _forward_users = bool(flags & 16)
+        _forward_chats = bool(flags & 32)
+        _groups = bool(flags & 1024)
+        _channels = bool(flags & 32768)
+        _offset = reader.read_int()
+        _limit = reader.read_int()
+        _hash = reader.read_long()
+        return cls(offset=_offset, limit=_limit, hash=_hash, correspondents=_correspondents, bots_pm=_bots_pm, bots_inline=_bots_inline, phone_calls=_phone_calls, forward_users=_forward_users, forward_chats=_forward_chats, groups=_groups, channels=_channels)
+
+
+class ImportContactTokenRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x13005788
+    SUBCLASS_OF_ID = 0x2da17977
+
+    def __init__(self, token: str):
+        """
+        :returns User: Instance of either UserEmpty, User.
+        """
+        self.token = token
+
+    def to_dict(self):
+        return {
+            '_': 'ImportContactTokenRequest',
+            'token': self.token
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x88W\x00\x13',
+            self.serialize_bytes(self.token),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _token = reader.tgread_string()
+        return cls(token=_token)
+
+
+class ImportContactsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x2c800be5
+    SUBCLASS_OF_ID = 0x8172ad93
+
+    def __init__(self, contacts: List['TypeInputContact']):
+        """
+        :returns contacts.ImportedContacts: Instance of ImportedContacts.
+        """
+        self.contacts = contacts
+
+    def to_dict(self):
+        return {
+            '_': 'ImportContactsRequest',
+            'contacts': [] if self.contacts is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.contacts]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xe5\x0b\x80,',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.contacts)),b''.join(x._bytes() for x in self.contacts),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _contacts = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _contacts.append(_x)
+
+        return cls(contacts=_contacts)
+
+
+class ResetSavedRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x879537f1
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def to_dict(self):
+        return {
+            '_': 'ResetSavedRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xf17\x95\x87',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class ResetTopPeerRatingRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x1ae373ac
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, category: 'TypeTopPeerCategory', peer: 'TypeInputPeer'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.category = category
+        self.peer = peer
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'ResetTopPeerRatingRequest',
+            'category': self.category.to_dict() if isinstance(self.category, TLObject) else self.category,
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xacs\xe3\x1a',
+            self.category._bytes(),
+            self.peer._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _category = reader.tgread_object()
+        _peer = reader.tgread_object()
+        return cls(category=_category, peer=_peer)
+
+
+class ResolvePhoneRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x8af94344
+    SUBCLASS_OF_ID = 0xf065b3a8
+
+    def __init__(self, phone: str):
+        """
+        :returns contacts.ResolvedPeer: Instance of ResolvedPeer.
+        """
+        self.phone = phone
+
+    def to_dict(self):
+        return {
+            '_': 'ResolvePhoneRequest',
+            'phone': self.phone
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'DC\xf9\x8a',
+            self.serialize_bytes(self.phone),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _phone = reader.tgread_string()
+        return cls(phone=_phone)
+
+
+class ResolveUsernameRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf93ccba3
+    SUBCLASS_OF_ID = 0xf065b3a8
+
+    def __init__(self, username: str):
+        """
+        :returns contacts.ResolvedPeer: Instance of ResolvedPeer.
+        """
+        self.username = username
+
+    def to_dict(self):
+        return {
+            '_': 'ResolveUsernameRequest',
+            'username': self.username
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xa3\xcb<\xf9',
+            self.serialize_bytes(self.username),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _username = reader.tgread_string()
+        return cls(username=_username)
+
+
+class SearchRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x11f812d8
+    SUBCLASS_OF_ID = 0x4386a2e3
+
+    def __init__(self, q: str, limit: int):
+        """
+        :returns contacts.Found: Instance of Found.
+        """
+        self.q = q
+        self.limit = limit
+
+    def to_dict(self):
+        return {
+            '_': 'SearchRequest',
+            'q': self.q,
+            'limit': self.limit
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xd8\x12\xf8\x11',
+            self.serialize_bytes(self.q),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _q = reader.tgread_string()
+        _limit = reader.read_int()
+        return cls(q=_q, limit=_limit)
+
+
+class SetBlockedRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x94c65c76
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, id: List['TypeInputPeer'], limit: int, my_stories_from: Optional[bool]=None):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.id = id
+        self.limit = limit
+        self.my_stories_from = my_stories_from
+
+    async def resolve(self, client, utils):
+        _tmp = []
+        for _x in self.id:
+            _tmp.append(utils.get_input_peer(await client.get_input_entity(_x)))
+
+        self.id = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'SetBlockedRequest',
+            'id': [] if self.id is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.id],
+            'limit': self.limit,
+            'my_stories_from': self.my_stories_from
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'v\\\xc6\x94',
+            struct.pack('<I', (0 if self.my_stories_from is None or self.my_stories_from is False else 1)),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.id)),b''.join(x._bytes() for x in self.id),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _my_stories_from = bool(flags & 1)
+        reader.read_int()
+        _id = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _id.append(_x)
+
+        _limit = reader.read_int()
+        return cls(id=_id, limit=_limit, my_stories_from=_my_stories_from)
+
+
+class ToggleTopPeersRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x8514bdda
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, enabled: bool):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.enabled = enabled
+
+    def to_dict(self):
+        return {
+            '_': 'ToggleTopPeersRequest',
+            'enabled': self.enabled
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xda\xbd\x14\x85',
+            b'\xb5ur\x99' if self.enabled else b'7\x97y\xbc',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _enabled = reader.tgread_bool()
+        return cls(enabled=_enabled)
+
+
+class UnblockRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xb550d328
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, id: 'TypeInputPeer', my_stories_from: Optional[bool]=None):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.id = id
+        self.my_stories_from = my_stories_from
+
+    async def resolve(self, client, utils):
+        self.id = utils.get_input_peer(await client.get_input_entity(self.id))
+
+    def to_dict(self):
+        return {
+            '_': 'UnblockRequest',
+            'id': self.id.to_dict() if isinstance(self.id, TLObject) else self.id,
+            'my_stories_from': self.my_stories_from
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'(\xd3P\xb5',
+            struct.pack('<I', (0 if self.my_stories_from is None or self.my_stories_from is False else 1)),
+            self.id._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _my_stories_from = bool(flags & 1)
+        _id = reader.tgread_object()
+        return cls(id=_id, my_stories_from=_my_stories_from)
+

.venv2/Lib/site-packages/telethon/tl/functions/folders.py

@@ -0,0 +1,44 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputFolderPeer
+
+
+
+class EditPeerFoldersRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x6847d0ab
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, folder_peers: List['TypeInputFolderPeer']):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.folder_peers = folder_peers
+
+    def to_dict(self):
+        return {
+            '_': 'EditPeerFoldersRequest',
+            'folder_peers': [] if self.folder_peers is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.folder_peers]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xab\xd0Gh',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.folder_peers)),b''.join(x._bytes() for x in self.folder_peers),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _folder_peers = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _folder_peers.append(_x)
+
+        return cls(folder_peers=_folder_peers)
+

.venv2/Lib/site-packages/telethon/tl/functions/help.py

@@ -0,0 +1,644 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeDataJSON, TypeInputAppEvent, TypeInputPeer, TypeInputUser, TypeMessageEntity
+
+
+
+class AcceptTermsOfServiceRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xee72f79a
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, id: 'TypeDataJSON'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.id = id
+
+    def to_dict(self):
+        return {
+            '_': 'AcceptTermsOfServiceRequest',
+            'id': self.id.to_dict() if isinstance(self.id, TLObject) else self.id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x9a\xf7r\xee',
+            self.id._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _id = reader.tgread_object()
+        return cls(id=_id)
+
+
+class DismissSuggestionRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf50dbaa1
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, peer: 'TypeInputPeer', suggestion: str):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.peer = peer
+        self.suggestion = suggestion
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'DismissSuggestionRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer,
+            'suggestion': self.suggestion
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xa1\xba\r\xf5',
+            self.peer._bytes(),
+            self.serialize_bytes(self.suggestion),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _peer = reader.tgread_object()
+        _suggestion = reader.tgread_string()
+        return cls(peer=_peer, suggestion=_suggestion)
+
+
+class EditUserInfoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x66b91b70
+    SUBCLASS_OF_ID = 0x5c53d7d8
+
+    def __init__(self, user_id: 'TypeInputUser', message: str, entities: List['TypeMessageEntity']):
+        """
+        :returns help.UserInfo: Instance of either UserInfoEmpty, UserInfo.
+        """
+        self.user_id = user_id
+        self.message = message
+        self.entities = entities
+
+    async def resolve(self, client, utils):
+        self.user_id = utils.get_input_user(await client.get_input_entity(self.user_id))
+
+    def to_dict(self):
+        return {
+            '_': 'EditUserInfoRequest',
+            'user_id': self.user_id.to_dict() if isinstance(self.user_id, TLObject) else self.user_id,
+            'message': self.message,
+            'entities': [] if self.entities is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.entities]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'p\x1b\xb9f',
+            self.user_id._bytes(),
+            self.serialize_bytes(self.message),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.entities)),b''.join(x._bytes() for x in self.entities),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _user_id = reader.tgread_object()
+        _message = reader.tgread_string()
+        reader.read_int()
+        _entities = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _entities.append(_x)
+
+        return cls(user_id=_user_id, message=_message, entities=_entities)
+
+
+class GetAppConfigRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x61e3f854
+    SUBCLASS_OF_ID = 0x14381c9a
+
+    def __init__(self, hash: int):
+        """
+        :returns help.AppConfig: Instance of either AppConfigNotModified, AppConfig.
+        """
+        self.hash = hash
+
+    def to_dict(self):
+        return {
+            '_': 'GetAppConfigRequest',
+            'hash': self.hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'T\xf8\xe3a',
+            struct.pack('<i', self.hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _hash = reader.read_int()
+        return cls(hash=_hash)
+
+
+class GetAppUpdateRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x522d5a7d
+    SUBCLASS_OF_ID = 0x5897069e
+
+    def __init__(self, source: str):
+        """
+        :returns help.AppUpdate: Instance of either AppUpdate, NoAppUpdate.
+        """
+        self.source = source
+
+    def to_dict(self):
+        return {
+            '_': 'GetAppUpdateRequest',
+            'source': self.source
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'}Z-R',
+            self.serialize_bytes(self.source),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _source = reader.tgread_string()
+        return cls(source=_source)
+
+
+class GetCdnConfigRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x52029342
+    SUBCLASS_OF_ID = 0xecda397c
+
+    def to_dict(self):
+        return {
+            '_': 'GetCdnConfigRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'B\x93\x02R',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetConfigRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xc4f9186b
+    SUBCLASS_OF_ID = 0xd3262a4a
+
+    def to_dict(self):
+        return {
+            '_': 'GetConfigRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'k\x18\xf9\xc4',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetCountriesListRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x735787a8
+    SUBCLASS_OF_ID = 0xea31fe88
+
+    def __init__(self, lang_code: str, hash: int):
+        """
+        :returns help.CountriesList: Instance of either CountriesListNotModified, CountriesList.
+        """
+        self.lang_code = lang_code
+        self.hash = hash
+
+    def to_dict(self):
+        return {
+            '_': 'GetCountriesListRequest',
+            'lang_code': self.lang_code,
+            'hash': self.hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xa8\x87Ws',
+            self.serialize_bytes(self.lang_code),
+            struct.pack('<i', self.hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _lang_code = reader.tgread_string()
+        _hash = reader.read_int()
+        return cls(lang_code=_lang_code, hash=_hash)
+
+
+class GetDeepLinkInfoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x3fedc75f
+    SUBCLASS_OF_ID = 0x984aac38
+
+    def __init__(self, path: str):
+        """
+        :returns help.DeepLinkInfo: Instance of either DeepLinkInfoEmpty, DeepLinkInfo.
+        """
+        self.path = path
+
+    def to_dict(self):
+        return {
+            '_': 'GetDeepLinkInfoRequest',
+            'path': self.path
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'_\xc7\xed?',
+            self.serialize_bytes(self.path),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _path = reader.tgread_string()
+        return cls(path=_path)
+
+
+class GetInviteTextRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x4d392343
+    SUBCLASS_OF_ID = 0xcf70aa35
+
+    def to_dict(self):
+        return {
+            '_': 'GetInviteTextRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'C#9M',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetNearestDcRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x1fb33026
+    SUBCLASS_OF_ID = 0x3877045f
+
+    def to_dict(self):
+        return {
+            '_': 'GetNearestDcRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'&0\xb3\x1f',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetPassportConfigRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xc661ad08
+    SUBCLASS_OF_ID = 0xc666c0ad
+
+    def __init__(self, hash: int):
+        """
+        :returns help.PassportConfig: Instance of either PassportConfigNotModified, PassportConfig.
+        """
+        self.hash = hash
+
+    def to_dict(self):
+        return {
+            '_': 'GetPassportConfigRequest',
+            'hash': self.hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x08\xada\xc6',
+            struct.pack('<i', self.hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _hash = reader.read_int()
+        return cls(hash=_hash)
+
+
+class GetPeerColorsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xda80f42f
+    SUBCLASS_OF_ID = 0xe3f6733
+
+    def __init__(self, hash: int):
+        """
+        :returns help.PeerColors: Instance of either PeerColorsNotModified, PeerColors.
+        """
+        self.hash = hash
+
+    def to_dict(self):
+        return {
+            '_': 'GetPeerColorsRequest',
+            'hash': self.hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'/\xf4\x80\xda',
+            struct.pack('<i', self.hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _hash = reader.read_int()
+        return cls(hash=_hash)
+
+
+class GetPeerProfileColorsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xabcfa9fd
+    SUBCLASS_OF_ID = 0xe3f6733
+
+    def __init__(self, hash: int):
+        """
+        :returns help.PeerColors: Instance of either PeerColorsNotModified, PeerColors.
+        """
+        self.hash = hash
+
+    def to_dict(self):
+        return {
+            '_': 'GetPeerProfileColorsRequest',
+            'hash': self.hash
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xfd\xa9\xcf\xab',
+            struct.pack('<i', self.hash),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _hash = reader.read_int()
+        return cls(hash=_hash)
+
+
+class GetPremiumPromoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xb81b93d4
+    SUBCLASS_OF_ID = 0xc987a338
+
+    def to_dict(self):
+        return {
+            '_': 'GetPremiumPromoRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xd4\x93\x1b\xb8',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetPromoDataRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xc0977421
+    SUBCLASS_OF_ID = 0x9d595542
+
+    def to_dict(self):
+        return {
+            '_': 'GetPromoDataRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'!t\x97\xc0',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetRecentMeUrlsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x3dc0f114
+    SUBCLASS_OF_ID = 0xf269c477
+
+    def __init__(self, referer: str):
+        """
+        :returns help.RecentMeUrls: Instance of RecentMeUrls.
+        """
+        self.referer = referer
+
+    def to_dict(self):
+        return {
+            '_': 'GetRecentMeUrlsRequest',
+            'referer': self.referer
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x14\xf1\xc0=',
+            self.serialize_bytes(self.referer),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _referer = reader.tgread_string()
+        return cls(referer=_referer)
+
+
+class GetSupportRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9cdf08cd
+    SUBCLASS_OF_ID = 0x7159bceb
+
+    def to_dict(self):
+        return {
+            '_': 'GetSupportRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xcd\x08\xdf\x9c',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetSupportNameRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xd360e72c
+    SUBCLASS_OF_ID = 0x7f50b7c2
+
+    def to_dict(self):
+        return {
+            '_': 'GetSupportNameRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b',\xe7`\xd3',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetTermsOfServiceUpdateRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x2ca51fd1
+    SUBCLASS_OF_ID = 0x293c2977
+
+    def to_dict(self):
+        return {
+            '_': 'GetTermsOfServiceUpdateRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xd1\x1f\xa5,',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetUserInfoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x38a08d3
+    SUBCLASS_OF_ID = 0x5c53d7d8
+
+    def __init__(self, user_id: 'TypeInputUser'):
+        """
+        :returns help.UserInfo: Instance of either UserInfoEmpty, UserInfo.
+        """
+        self.user_id = user_id
+
+    async def resolve(self, client, utils):
+        self.user_id = utils.get_input_user(await client.get_input_entity(self.user_id))
+
+    def to_dict(self):
+        return {
+            '_': 'GetUserInfoRequest',
+            'user_id': self.user_id.to_dict() if isinstance(self.user_id, TLObject) else self.user_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xd3\x08\x8a\x03',
+            self.user_id._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _user_id = reader.tgread_object()
+        return cls(user_id=_user_id)
+
+
+class HidePromoDataRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x1e251c95
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, peer: 'TypeInputPeer'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.peer = peer
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'HidePromoDataRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x95\x1c%\x1e',
+            self.peer._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _peer = reader.tgread_object()
+        return cls(peer=_peer)
+
+
+class SaveAppLogRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x6f02f748
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, events: List['TypeInputAppEvent']):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.events = events
+
+    def to_dict(self):
+        return {
+            '_': 'SaveAppLogRequest',
+            'events': [] if self.events is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.events]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'H\xf7\x02o',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.events)),b''.join(x._bytes() for x in self.events),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _events = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _events.append(_x)
+
+        return cls(events=_events)
+
+
+class SetBotUpdatesStatusRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xec22cfcd
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, pending_updates_count: int, message: str):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.pending_updates_count = pending_updates_count
+        self.message = message
+
+    def to_dict(self):
+        return {
+            '_': 'SetBotUpdatesStatusRequest',
+            'pending_updates_count': self.pending_updates_count,
+            'message': self.message
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xcd\xcf"\xec',
+            struct.pack('<i', self.pending_updates_count),
+            self.serialize_bytes(self.message),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _pending_updates_count = reader.read_int()
+        _message = reader.tgread_string()
+        return cls(pending_updates_count=_pending_updates_count, message=_message)
+

.venv2/Lib/site-packages/telethon/tl/functions/langpack.py

@@ -0,0 +1,178 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+
+
+class GetDifferenceRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xcd984aa5
+    SUBCLASS_OF_ID = 0x52662d55
+
+    def __init__(self, lang_pack: str, lang_code: str, from_version: int):
+        """
+        :returns LangPackDifference: Instance of LangPackDifference.
+        """
+        self.lang_pack = lang_pack
+        self.lang_code = lang_code
+        self.from_version = from_version
+
+    def to_dict(self):
+        return {
+            '_': 'GetDifferenceRequest',
+            'lang_pack': self.lang_pack,
+            'lang_code': self.lang_code,
+            'from_version': self.from_version
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xa5J\x98\xcd',
+            self.serialize_bytes(self.lang_pack),
+            self.serialize_bytes(self.lang_code),
+            struct.pack('<i', self.from_version),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _lang_pack = reader.tgread_string()
+        _lang_code = reader.tgread_string()
+        _from_version = reader.read_int()
+        return cls(lang_pack=_lang_pack, lang_code=_lang_code, from_version=_from_version)
+
+
+class GetLangPackRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf2f2330a
+    SUBCLASS_OF_ID = 0x52662d55
+
+    def __init__(self, lang_pack: str, lang_code: str):
+        """
+        :returns LangPackDifference: Instance of LangPackDifference.
+        """
+        self.lang_pack = lang_pack
+        self.lang_code = lang_code
+
+    def to_dict(self):
+        return {
+            '_': 'GetLangPackRequest',
+            'lang_pack': self.lang_pack,
+            'lang_code': self.lang_code
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\n3\xf2\xf2',
+            self.serialize_bytes(self.lang_pack),
+            self.serialize_bytes(self.lang_code),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _lang_pack = reader.tgread_string()
+        _lang_code = reader.tgread_string()
+        return cls(lang_pack=_lang_pack, lang_code=_lang_code)
+
+
+class GetLanguageRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x6a596502
+    SUBCLASS_OF_ID = 0xabac89b7
+
+    def __init__(self, lang_pack: str, lang_code: str):
+        """
+        :returns LangPackLanguage: Instance of LangPackLanguage.
+        """
+        self.lang_pack = lang_pack
+        self.lang_code = lang_code
+
+    def to_dict(self):
+        return {
+            '_': 'GetLanguageRequest',
+            'lang_pack': self.lang_pack,
+            'lang_code': self.lang_code
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x02eYj',
+            self.serialize_bytes(self.lang_pack),
+            self.serialize_bytes(self.lang_code),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _lang_pack = reader.tgread_string()
+        _lang_code = reader.tgread_string()
+        return cls(lang_pack=_lang_pack, lang_code=_lang_code)
+
+
+class GetLanguagesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x42c6978f
+    SUBCLASS_OF_ID = 0x280912c9
+
+    def __init__(self, lang_pack: str):
+        """
+        :returns Vector<LangPackLanguage>: This type has no constructors.
+        """
+        self.lang_pack = lang_pack
+
+    def to_dict(self):
+        return {
+            '_': 'GetLanguagesRequest',
+            'lang_pack': self.lang_pack
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x8f\x97\xc6B',
+            self.serialize_bytes(self.lang_pack),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _lang_pack = reader.tgread_string()
+        return cls(lang_pack=_lang_pack)
+
+
+class GetStringsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xefea3803
+    SUBCLASS_OF_ID = 0xc7b7353d
+
+    # noinspection PyShadowingBuiltins
+    def __init__(self, lang_pack: str, lang_code: str, keys: List[str]):
+        """
+        :returns Vector<LangPackString>: This type has no constructors.
+        """
+        self.lang_pack = lang_pack
+        self.lang_code = lang_code
+        self.keys = keys
+
+    def to_dict(self):
+        return {
+            '_': 'GetStringsRequest',
+            'lang_pack': self.lang_pack,
+            'lang_code': self.lang_code,
+            'keys': [] if self.keys is None else self.keys[:]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x038\xea\xef',
+            self.serialize_bytes(self.lang_pack),
+            self.serialize_bytes(self.lang_code),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.keys)),b''.join(self.serialize_bytes(x) for x in self.keys),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _lang_pack = reader.tgread_string()
+        _lang_code = reader.tgread_string()
+        reader.read_int()
+        _keys = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_string()
+            _keys.append(_x)
+
+        return cls(lang_pack=_lang_pack, lang_code=_lang_code, keys=_keys)
+

.venv2/Lib/site-packages/telethon/tl/functions/payments.py

@@ -0,0 +1,553 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeDataJSON, TypeInputInvoice, TypeInputMedia, TypeInputPaymentCredentials, TypeInputPeer, TypeInputStorePaymentPurpose, TypePaymentRequestedInfo
+
+
+
+class ApplyGiftCodeRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf6e26854
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, slug: str):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.slug = slug
+
+    def to_dict(self):
+        return {
+            '_': 'ApplyGiftCodeRequest',
+            'slug': self.slug
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'Th\xe2\xf6',
+            self.serialize_bytes(self.slug),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _slug = reader.tgread_string()
+        return cls(slug=_slug)
+
+
+class AssignAppStoreTransactionRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x80ed747d
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, receipt: bytes, purpose: 'TypeInputStorePaymentPurpose'):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.receipt = receipt
+        self.purpose = purpose
+
+    def to_dict(self):
+        return {
+            '_': 'AssignAppStoreTransactionRequest',
+            'receipt': self.receipt,
+            'purpose': self.purpose.to_dict() if isinstance(self.purpose, TLObject) else self.purpose
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'}t\xed\x80',
+            self.serialize_bytes(self.receipt),
+            self.purpose._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _receipt = reader.tgread_bytes()
+        _purpose = reader.tgread_object()
+        return cls(receipt=_receipt, purpose=_purpose)
+
+
+class AssignPlayMarketTransactionRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xdffd50d3
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, receipt: 'TypeDataJSON', purpose: 'TypeInputStorePaymentPurpose'):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.receipt = receipt
+        self.purpose = purpose
+
+    def to_dict(self):
+        return {
+            '_': 'AssignPlayMarketTransactionRequest',
+            'receipt': self.receipt.to_dict() if isinstance(self.receipt, TLObject) else self.receipt,
+            'purpose': self.purpose.to_dict() if isinstance(self.purpose, TLObject) else self.purpose
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xd3P\xfd\xdf',
+            self.receipt._bytes(),
+            self.purpose._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _receipt = reader.tgread_object()
+        _purpose = reader.tgread_object()
+        return cls(receipt=_receipt, purpose=_purpose)
+
+
+class CanPurchasePremiumRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9fc19eb6
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, purpose: 'TypeInputStorePaymentPurpose'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.purpose = purpose
+
+    def to_dict(self):
+        return {
+            '_': 'CanPurchasePremiumRequest',
+            'purpose': self.purpose.to_dict() if isinstance(self.purpose, TLObject) else self.purpose
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xb6\x9e\xc1\x9f',
+            self.purpose._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _purpose = reader.tgread_object()
+        return cls(purpose=_purpose)
+
+
+class CheckGiftCodeRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x8e51b4c1
+    SUBCLASS_OF_ID = 0x5b2997e8
+
+    def __init__(self, slug: str):
+        """
+        :returns payments.CheckedGiftCode: Instance of CheckedGiftCode.
+        """
+        self.slug = slug
+
+    def to_dict(self):
+        return {
+            '_': 'CheckGiftCodeRequest',
+            'slug': self.slug
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xc1\xb4Q\x8e',
+            self.serialize_bytes(self.slug),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _slug = reader.tgread_string()
+        return cls(slug=_slug)
+
+
+class ClearSavedInfoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xd83d70c1
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, credentials: Optional[bool]=None, info: Optional[bool]=None):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.credentials = credentials
+        self.info = info
+
+    def to_dict(self):
+        return {
+            '_': 'ClearSavedInfoRequest',
+            'credentials': self.credentials,
+            'info': self.info
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xc1p=\xd8',
+            struct.pack('<I', (0 if self.credentials is None or self.credentials is False else 1) | (0 if self.info is None or self.info is False else 2)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _credentials = bool(flags & 1)
+        _info = bool(flags & 2)
+        return cls(credentials=_credentials, info=_info)
+
+
+class ExportInvoiceRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf91b065
+    SUBCLASS_OF_ID = 0x36105432
+
+    def __init__(self, invoice_media: 'TypeInputMedia'):
+        """
+        :returns payments.ExportedInvoice: Instance of ExportedInvoice.
+        """
+        self.invoice_media = invoice_media
+
+    async def resolve(self, client, utils):
+        self.invoice_media = utils.get_input_media(self.invoice_media)
+
+    def to_dict(self):
+        return {
+            '_': 'ExportInvoiceRequest',
+            'invoice_media': self.invoice_media.to_dict() if isinstance(self.invoice_media, TLObject) else self.invoice_media
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'e\xb0\x91\x0f',
+            self.invoice_media._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _invoice_media = reader.tgread_object()
+        return cls(invoice_media=_invoice_media)
+
+
+class GetBankCardDataRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x2e79d779
+    SUBCLASS_OF_ID = 0x8c6dd68b
+
+    def __init__(self, number: str):
+        """
+        :returns payments.BankCardData: Instance of BankCardData.
+        """
+        self.number = number
+
+    def to_dict(self):
+        return {
+            '_': 'GetBankCardDataRequest',
+            'number': self.number
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'y\xd7y.',
+            self.serialize_bytes(self.number),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _number = reader.tgread_string()
+        return cls(number=_number)
+
+
+class GetGiveawayInfoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf4239425
+    SUBCLASS_OF_ID = 0x96a377bd
+
+    def __init__(self, peer: 'TypeInputPeer', msg_id: int):
+        """
+        :returns payments.GiveawayInfo: Instance of either GiveawayInfo, GiveawayInfoResults.
+        """
+        self.peer = peer
+        self.msg_id = msg_id
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'GetGiveawayInfoRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer,
+            'msg_id': self.msg_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'%\x94#\xf4',
+            self.peer._bytes(),
+            struct.pack('<i', self.msg_id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _peer = reader.tgread_object()
+        _msg_id = reader.read_int()
+        return cls(peer=_peer, msg_id=_msg_id)
+
+
+class GetPaymentFormRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x37148dbb
+    SUBCLASS_OF_ID = 0xa0483f19
+
+    def __init__(self, invoice: 'TypeInputInvoice', theme_params: Optional['TypeDataJSON']=None):
+        """
+        :returns payments.PaymentForm: Instance of PaymentForm.
+        """
+        self.invoice = invoice
+        self.theme_params = theme_params
+
+    def to_dict(self):
+        return {
+            '_': 'GetPaymentFormRequest',
+            'invoice': self.invoice.to_dict() if isinstance(self.invoice, TLObject) else self.invoice,
+            'theme_params': self.theme_params.to_dict() if isinstance(self.theme_params, TLObject) else self.theme_params
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xbb\x8d\x147',
+            struct.pack('<I', (0 if self.theme_params is None or self.theme_params is False else 1)),
+            self.invoice._bytes(),
+            b'' if self.theme_params is None or self.theme_params is False else (self.theme_params._bytes()),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _invoice = reader.tgread_object()
+        if flags & 1:
+            _theme_params = reader.tgread_object()
+        else:
+            _theme_params = None
+        return cls(invoice=_invoice, theme_params=_theme_params)
+
+
+class GetPaymentReceiptRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x2478d1cc
+    SUBCLASS_OF_ID = 0x590093c9
+
+    def __init__(self, peer: 'TypeInputPeer', msg_id: int):
+        """
+        :returns payments.PaymentReceipt: Instance of PaymentReceipt.
+        """
+        self.peer = peer
+        self.msg_id = msg_id
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'GetPaymentReceiptRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer,
+            'msg_id': self.msg_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xcc\xd1x$',
+            self.peer._bytes(),
+            struct.pack('<i', self.msg_id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _peer = reader.tgread_object()
+        _msg_id = reader.read_int()
+        return cls(peer=_peer, msg_id=_msg_id)
+
+
+class GetPremiumGiftCodeOptionsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x2757ba54
+    SUBCLASS_OF_ID = 0xaa92583
+
+    def __init__(self, boost_peer: Optional['TypeInputPeer']=None):
+        """
+        :returns Vector<PremiumGiftCodeOption>: This type has no constructors.
+        """
+        self.boost_peer = boost_peer
+
+    async def resolve(self, client, utils):
+        if self.boost_peer:
+            self.boost_peer = utils.get_input_peer(await client.get_input_entity(self.boost_peer))
+
+    def to_dict(self):
+        return {
+            '_': 'GetPremiumGiftCodeOptionsRequest',
+            'boost_peer': self.boost_peer.to_dict() if isinstance(self.boost_peer, TLObject) else self.boost_peer
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b"T\xbaW'",
+            struct.pack('<I', (0 if self.boost_peer is None or self.boost_peer is False else 1)),
+            b'' if self.boost_peer is None or self.boost_peer is False else (self.boost_peer._bytes()),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        if flags & 1:
+            _boost_peer = reader.tgread_object()
+        else:
+            _boost_peer = None
+        return cls(boost_peer=_boost_peer)
+
+
+class GetSavedInfoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x227d824b
+    SUBCLASS_OF_ID = 0xad3cf146
+
+    def to_dict(self):
+        return {
+            '_': 'GetSavedInfoRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'K\x82}"',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class LaunchPrepaidGiveawayRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x5ff58f20
+    SUBCLASS_OF_ID = 0x8af52aac
+
+    def __init__(self, peer: 'TypeInputPeer', giveaway_id: int, purpose: 'TypeInputStorePaymentPurpose'):
+        """
+        :returns Updates: Instance of either UpdatesTooLong, UpdateShortMessage, UpdateShortChatMessage, UpdateShort, UpdatesCombined, Updates, UpdateShortSentMessage.
+        """
+        self.peer = peer
+        self.giveaway_id = giveaway_id
+        self.purpose = purpose
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'LaunchPrepaidGiveawayRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer,
+            'giveaway_id': self.giveaway_id,
+            'purpose': self.purpose.to_dict() if isinstance(self.purpose, TLObject) else self.purpose
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b' \x8f\xf5_',
+            self.peer._bytes(),
+            struct.pack('<q', self.giveaway_id),
+            self.purpose._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _peer = reader.tgread_object()
+        _giveaway_id = reader.read_long()
+        _purpose = reader.tgread_object()
+        return cls(peer=_peer, giveaway_id=_giveaway_id, purpose=_purpose)
+
+
+class SendPaymentFormRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x2d03522f
+    SUBCLASS_OF_ID = 0x8ae16a9d
+
+    def __init__(self, form_id: int, invoice: 'TypeInputInvoice', credentials: 'TypeInputPaymentCredentials', requested_info_id: Optional[str]=None, shipping_option_id: Optional[str]=None, tip_amount: Optional[int]=None):
+        """
+        :returns payments.PaymentResult: Instance of either PaymentResult, PaymentVerificationNeeded.
+        """
+        self.form_id = form_id
+        self.invoice = invoice
+        self.credentials = credentials
+        self.requested_info_id = requested_info_id
+        self.shipping_option_id = shipping_option_id
+        self.tip_amount = tip_amount
+
+    def to_dict(self):
+        return {
+            '_': 'SendPaymentFormRequest',
+            'form_id': self.form_id,
+            'invoice': self.invoice.to_dict() if isinstance(self.invoice, TLObject) else self.invoice,
+            'credentials': self.credentials.to_dict() if isinstance(self.credentials, TLObject) else self.credentials,
+            'requested_info_id': self.requested_info_id,
+            'shipping_option_id': self.shipping_option_id,
+            'tip_amount': self.tip_amount
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'/R\x03-',
+            struct.pack('<I', (0 if self.requested_info_id is None or self.requested_info_id is False else 1) | (0 if self.shipping_option_id is None or self.shipping_option_id is False else 2) | (0 if self.tip_amount is None or self.tip_amount is False else 4)),
+            struct.pack('<q', self.form_id),
+            self.invoice._bytes(),
+            b'' if self.requested_info_id is None or self.requested_info_id is False else (self.serialize_bytes(self.requested_info_id)),
+            b'' if self.shipping_option_id is None or self.shipping_option_id is False else (self.serialize_bytes(self.shipping_option_id)),
+            self.credentials._bytes(),
+            b'' if self.tip_amount is None or self.tip_amount is False else (struct.pack('<q', self.tip_amount)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _form_id = reader.read_long()
+        _invoice = reader.tgread_object()
+        if flags & 1:
+            _requested_info_id = reader.tgread_string()
+        else:
+            _requested_info_id = None
+        if flags & 2:
+            _shipping_option_id = reader.tgread_string()
+        else:
+            _shipping_option_id = None
+        _credentials = reader.tgread_object()
+        if flags & 4:
+            _tip_amount = reader.read_long()
+        else:
+            _tip_amount = None
+        return cls(form_id=_form_id, invoice=_invoice, credentials=_credentials, requested_info_id=_requested_info_id, shipping_option_id=_shipping_option_id, tip_amount=_tip_amount)
+
+
+class ValidateRequestedInfoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xb6c8f12b
+    SUBCLASS_OF_ID = 0x8f8044b7
+
+    def __init__(self, invoice: 'TypeInputInvoice', info: 'TypePaymentRequestedInfo', save: Optional[bool]=None):
+        """
+        :returns payments.ValidatedRequestedInfo: Instance of ValidatedRequestedInfo.
+        """
+        self.invoice = invoice
+        self.info = info
+        self.save = save
+
+    def to_dict(self):
+        return {
+            '_': 'ValidateRequestedInfoRequest',
+            'invoice': self.invoice.to_dict() if isinstance(self.invoice, TLObject) else self.invoice,
+            'info': self.info.to_dict() if isinstance(self.info, TLObject) else self.info,
+            'save': self.save
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'+\xf1\xc8\xb6',
+            struct.pack('<I', (0 if self.save is None or self.save is False else 1)),
+            self.invoice._bytes(),
+            self.info._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _save = bool(flags & 1)
+        _invoice = reader.tgread_object()
+        _info = reader.tgread_object()
+        return cls(invoice=_invoice, info=_info, save=_save)
+

.venv2/Lib/site-packages/telethon/tl/functions/photos.py

@@ -0,0 +1,282 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputFile, TypeInputPhoto, TypeInputUser, TypeVideoSize
+
+
+
+class DeletePhotosRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x87cf7f2f
+    SUBCLASS_OF_ID = 0x8918e168
+
+    def __init__(self, id: List['TypeInputPhoto']):
+        """
+        :returns Vector<long>: This type has no constructors.
+        """
+        self.id = id
+
+    async def resolve(self, client, utils):
+        _tmp = []
+        for _x in self.id:
+            _tmp.append(utils.get_input_photo(_x))
+
+        self.id = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'DeletePhotosRequest',
+            'id': [] if self.id is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.id]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'/\x7f\xcf\x87',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.id)),b''.join(x._bytes() for x in self.id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _id = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _id.append(_x)
+
+        return cls(id=_id)
+
+    @staticmethod
+    def read_result(reader):
+        reader.read_int()  # Vector ID
+        return [reader.read_long() for _ in range(reader.read_int())]
+
+
+class GetUserPhotosRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x91cd32a8
+    SUBCLASS_OF_ID = 0x27cfb967
+
+    def __init__(self, user_id: 'TypeInputUser', offset: int, max_id: int, limit: int):
+        """
+        :returns photos.Photos: Instance of either Photos, PhotosSlice.
+        """
+        self.user_id = user_id
+        self.offset = offset
+        self.max_id = max_id
+        self.limit = limit
+
+    async def resolve(self, client, utils):
+        self.user_id = utils.get_input_user(await client.get_input_entity(self.user_id))
+
+    def to_dict(self):
+        return {
+            '_': 'GetUserPhotosRequest',
+            'user_id': self.user_id.to_dict() if isinstance(self.user_id, TLObject) else self.user_id,
+            'offset': self.offset,
+            'max_id': self.max_id,
+            'limit': self.limit
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xa82\xcd\x91',
+            self.user_id._bytes(),
+            struct.pack('<i', self.offset),
+            struct.pack('<q', self.max_id),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _user_id = reader.tgread_object()
+        _offset = reader.read_int()
+        _max_id = reader.read_long()
+        _limit = reader.read_int()
+        return cls(user_id=_user_id, offset=_offset, max_id=_max_id, limit=_limit)
+
+
+class UpdateProfilePhotoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9e82039
+    SUBCLASS_OF_ID = 0xc292bd24
+
+    def __init__(self, id: 'TypeInputPhoto', fallback: Optional[bool]=None, bot: Optional['TypeInputUser']=None):
+        """
+        :returns photos.Photo: Instance of Photo.
+        """
+        self.id = id
+        self.fallback = fallback
+        self.bot = bot
+
+    async def resolve(self, client, utils):
+        self.id = utils.get_input_photo(self.id)
+        if self.bot:
+            self.bot = utils.get_input_user(await client.get_input_entity(self.bot))
+
+    def to_dict(self):
+        return {
+            '_': 'UpdateProfilePhotoRequest',
+            'id': self.id.to_dict() if isinstance(self.id, TLObject) else self.id,
+            'fallback': self.fallback,
+            'bot': self.bot.to_dict() if isinstance(self.bot, TLObject) else self.bot
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'9 \xe8\t',
+            struct.pack('<I', (0 if self.fallback is None or self.fallback is False else 1) | (0 if self.bot is None or self.bot is False else 2)),
+            b'' if self.bot is None or self.bot is False else (self.bot._bytes()),
+            self.id._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _fallback = bool(flags & 1)
+        if flags & 2:
+            _bot = reader.tgread_object()
+        else:
+            _bot = None
+        _id = reader.tgread_object()
+        return cls(id=_id, fallback=_fallback, bot=_bot)
+
+
+class UploadContactProfilePhotoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xe14c4a71
+    SUBCLASS_OF_ID = 0xc292bd24
+
+    def __init__(self, user_id: 'TypeInputUser', suggest: Optional[bool]=None, save: Optional[bool]=None, file: Optional['TypeInputFile']=None, video: Optional['TypeInputFile']=None, video_start_ts: Optional[float]=None, video_emoji_markup: Optional['TypeVideoSize']=None):
+        """
+        :returns photos.Photo: Instance of Photo.
+        """
+        self.user_id = user_id
+        self.suggest = suggest
+        self.save = save
+        self.file = file
+        self.video = video
+        self.video_start_ts = video_start_ts
+        self.video_emoji_markup = video_emoji_markup
+
+    async def resolve(self, client, utils):
+        self.user_id = utils.get_input_user(await client.get_input_entity(self.user_id))
+
+    def to_dict(self):
+        return {
+            '_': 'UploadContactProfilePhotoRequest',
+            'user_id': self.user_id.to_dict() if isinstance(self.user_id, TLObject) else self.user_id,
+            'suggest': self.suggest,
+            'save': self.save,
+            'file': self.file.to_dict() if isinstance(self.file, TLObject) else self.file,
+            'video': self.video.to_dict() if isinstance(self.video, TLObject) else self.video,
+            'video_start_ts': self.video_start_ts,
+            'video_emoji_markup': self.video_emoji_markup.to_dict() if isinstance(self.video_emoji_markup, TLObject) else self.video_emoji_markup
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'qJL\xe1',
+            struct.pack('<I', (0 if self.suggest is None or self.suggest is False else 8) | (0 if self.save is None or self.save is False else 16) | (0 if self.file is None or self.file is False else 1) | (0 if self.video is None or self.video is False else 2) | (0 if self.video_start_ts is None or self.video_start_ts is False else 4) | (0 if self.video_emoji_markup is None or self.video_emoji_markup is False else 32)),
+            self.user_id._bytes(),
+            b'' if self.file is None or self.file is False else (self.file._bytes()),
+            b'' if self.video is None or self.video is False else (self.video._bytes()),
+            b'' if self.video_start_ts is None or self.video_start_ts is False else (struct.pack('<d', self.video_start_ts)),
+            b'' if self.video_emoji_markup is None or self.video_emoji_markup is False else (self.video_emoji_markup._bytes()),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _suggest = bool(flags & 8)
+        _save = bool(flags & 16)
+        _user_id = reader.tgread_object()
+        if flags & 1:
+            _file = reader.tgread_object()
+        else:
+            _file = None
+        if flags & 2:
+            _video = reader.tgread_object()
+        else:
+            _video = None
+        if flags & 4:
+            _video_start_ts = reader.read_double()
+        else:
+            _video_start_ts = None
+        if flags & 32:
+            _video_emoji_markup = reader.tgread_object()
+        else:
+            _video_emoji_markup = None
+        return cls(user_id=_user_id, suggest=_suggest, save=_save, file=_file, video=_video, video_start_ts=_video_start_ts, video_emoji_markup=_video_emoji_markup)
+
+
+class UploadProfilePhotoRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x388a3b5
+    SUBCLASS_OF_ID = 0xc292bd24
+
+    def __init__(self, fallback: Optional[bool]=None, bot: Optional['TypeInputUser']=None, file: Optional['TypeInputFile']=None, video: Optional['TypeInputFile']=None, video_start_ts: Optional[float]=None, video_emoji_markup: Optional['TypeVideoSize']=None):
+        """
+        :returns photos.Photo: Instance of Photo.
+        """
+        self.fallback = fallback
+        self.bot = bot
+        self.file = file
+        self.video = video
+        self.video_start_ts = video_start_ts
+        self.video_emoji_markup = video_emoji_markup
+
+    async def resolve(self, client, utils):
+        if self.bot:
+            self.bot = utils.get_input_user(await client.get_input_entity(self.bot))
+
+    def to_dict(self):
+        return {
+            '_': 'UploadProfilePhotoRequest',
+            'fallback': self.fallback,
+            'bot': self.bot.to_dict() if isinstance(self.bot, TLObject) else self.bot,
+            'file': self.file.to_dict() if isinstance(self.file, TLObject) else self.file,
+            'video': self.video.to_dict() if isinstance(self.video, TLObject) else self.video,
+            'video_start_ts': self.video_start_ts,
+            'video_emoji_markup': self.video_emoji_markup.to_dict() if isinstance(self.video_emoji_markup, TLObject) else self.video_emoji_markup
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xb5\xa3\x88\x03',
+            struct.pack('<I', (0 if self.fallback is None or self.fallback is False else 8) | (0 if self.bot is None or self.bot is False else 32) | (0 if self.file is None or self.file is False else 1) | (0 if self.video is None or self.video is False else 2) | (0 if self.video_start_ts is None or self.video_start_ts is False else 4) | (0 if self.video_emoji_markup is None or self.video_emoji_markup is False else 16)),
+            b'' if self.bot is None or self.bot is False else (self.bot._bytes()),
+            b'' if self.file is None or self.file is False else (self.file._bytes()),
+            b'' if self.video is None or self.video is False else (self.video._bytes()),
+            b'' if self.video_start_ts is None or self.video_start_ts is False else (struct.pack('<d', self.video_start_ts)),
+            b'' if self.video_emoji_markup is None or self.video_emoji_markup is False else (self.video_emoji_markup._bytes()),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _fallback = bool(flags & 8)
+        if flags & 32:
+            _bot = reader.tgread_object()
+        else:
+            _bot = None
+        if flags & 1:
+            _file = reader.tgread_object()
+        else:
+            _file = None
+        if flags & 2:
+            _video = reader.tgread_object()
+        else:
+            _video = None
+        if flags & 4:
+            _video_start_ts = reader.read_double()
+        else:
+            _video_start_ts = None
+        if flags & 16:
+            _video_emoji_markup = reader.tgread_object()
+        else:
+            _video_emoji_markup = None
+        return cls(fallback=_fallback, bot=_bot, file=_file, video=_video, video_start_ts=_video_start_ts, video_emoji_markup=_video_emoji_markup)
+

.venv2/Lib/site-packages/telethon/tl/functions/premium.py

@@ -0,0 +1,188 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputPeer, TypeInputUser
+
+
+
+class ApplyBoostRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x6b7da746
+    SUBCLASS_OF_ID = 0xad3512db
+
+    def __init__(self, peer: 'TypeInputPeer', slots: Optional[List[int]]=None):
+        """
+        :returns premium.MyBoosts: Instance of MyBoosts.
+        """
+        self.peer = peer
+        self.slots = slots
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'ApplyBoostRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer,
+            'slots': [] if self.slots is None else self.slots[:]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'F\xa7}k',
+            struct.pack('<I', (0 if self.slots is None or self.slots is False else 1)),
+            b'' if self.slots is None or self.slots is False else b''.join((b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.slots)),b''.join(struct.pack('<i', x) for x in self.slots))),
+            self.peer._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        if flags & 1:
+            reader.read_int()
+            _slots = []
+            for _ in range(reader.read_int()):
+                _x = reader.read_int()
+                _slots.append(_x)
+
+        else:
+            _slots = None
+        _peer = reader.tgread_object()
+        return cls(peer=_peer, slots=_slots)
+
+
+class GetBoostsListRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x60f67660
+    SUBCLASS_OF_ID = 0x2235a8bd
+
+    def __init__(self, peer: 'TypeInputPeer', offset: str, limit: int, gifts: Optional[bool]=None):
+        """
+        :returns premium.BoostsList: Instance of BoostsList.
+        """
+        self.peer = peer
+        self.offset = offset
+        self.limit = limit
+        self.gifts = gifts
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'GetBoostsListRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer,
+            'offset': self.offset,
+            'limit': self.limit,
+            'gifts': self.gifts
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'`v\xf6`',
+            struct.pack('<I', (0 if self.gifts is None or self.gifts is False else 1)),
+            self.peer._bytes(),
+            self.serialize_bytes(self.offset),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _gifts = bool(flags & 1)
+        _peer = reader.tgread_object()
+        _offset = reader.tgread_string()
+        _limit = reader.read_int()
+        return cls(peer=_peer, offset=_offset, limit=_limit, gifts=_gifts)
+
+
+class GetBoostsStatusRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x42f1f61
+    SUBCLASS_OF_ID = 0xc31b1ab9
+
+    def __init__(self, peer: 'TypeInputPeer'):
+        """
+        :returns premium.BoostsStatus: Instance of BoostsStatus.
+        """
+        self.peer = peer
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'GetBoostsStatusRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'a\x1f/\x04',
+            self.peer._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _peer = reader.tgread_object()
+        return cls(peer=_peer)
+
+
+class GetMyBoostsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xbe77b4a
+    SUBCLASS_OF_ID = 0xad3512db
+
+    def to_dict(self):
+        return {
+            '_': 'GetMyBoostsRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'J{\xe7\x0b',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+
+
+class GetUserBoostsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x39854d1f
+    SUBCLASS_OF_ID = 0x2235a8bd
+
+    def __init__(self, peer: 'TypeInputPeer', user_id: 'TypeInputUser'):
+        """
+        :returns premium.BoostsList: Instance of BoostsList.
+        """
+        self.peer = peer
+        self.user_id = user_id
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+        self.user_id = utils.get_input_user(await client.get_input_entity(self.user_id))
+
+    def to_dict(self):
+        return {
+            '_': 'GetUserBoostsRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer,
+            'user_id': self.user_id.to_dict() if isinstance(self.user_id, TLObject) else self.user_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x1fM\x859',
+            self.peer._bytes(),
+            self.user_id._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _peer = reader.tgread_object()
+        _user_id = reader.tgread_object()
+        return cls(peer=_peer, user_id=_user_id)
+

.venv2/Lib/site-packages/telethon/tl/functions/stats.py

@@ -0,0 +1,291 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputChannel, TypeInputPeer
+
+
+
+class GetBroadcastStatsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xab42441a
+    SUBCLASS_OF_ID = 0x7ff25428
+
+    def __init__(self, channel: 'TypeInputChannel', dark: Optional[bool]=None):
+        """
+        :returns stats.BroadcastStats: Instance of BroadcastStats.
+        """
+        self.channel = channel
+        self.dark = dark
+
+    async def resolve(self, client, utils):
+        self.channel = utils.get_input_channel(await client.get_input_entity(self.channel))
+
+    def to_dict(self):
+        return {
+            '_': 'GetBroadcastStatsRequest',
+            'channel': self.channel.to_dict() if isinstance(self.channel, TLObject) else self.channel,
+            'dark': self.dark
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x1aDB\xab',
+            struct.pack('<I', (0 if self.dark is None or self.dark is False else 1)),
+            self.channel._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _dark = bool(flags & 1)
+        _channel = reader.tgread_object()
+        return cls(channel=_channel, dark=_dark)
+
+
+class GetMegagroupStatsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xdcdf8607
+    SUBCLASS_OF_ID = 0x5b59be8d
+
+    def __init__(self, channel: 'TypeInputChannel', dark: Optional[bool]=None):
+        """
+        :returns stats.MegagroupStats: Instance of MegagroupStats.
+        """
+        self.channel = channel
+        self.dark = dark
+
+    async def resolve(self, client, utils):
+        self.channel = utils.get_input_channel(await client.get_input_entity(self.channel))
+
+    def to_dict(self):
+        return {
+            '_': 'GetMegagroupStatsRequest',
+            'channel': self.channel.to_dict() if isinstance(self.channel, TLObject) else self.channel,
+            'dark': self.dark
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x07\x86\xdf\xdc',
+            struct.pack('<I', (0 if self.dark is None or self.dark is False else 1)),
+            self.channel._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _dark = bool(flags & 1)
+        _channel = reader.tgread_object()
+        return cls(channel=_channel, dark=_dark)
+
+
+class GetMessagePublicForwardsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x5f150144
+    SUBCLASS_OF_ID = 0xa7283211
+
+    def __init__(self, channel: 'TypeInputChannel', msg_id: int, offset: str, limit: int):
+        """
+        :returns stats.PublicForwards: Instance of PublicForwards.
+        """
+        self.channel = channel
+        self.msg_id = msg_id
+        self.offset = offset
+        self.limit = limit
+
+    async def resolve(self, client, utils):
+        self.channel = utils.get_input_channel(await client.get_input_entity(self.channel))
+
+    def to_dict(self):
+        return {
+            '_': 'GetMessagePublicForwardsRequest',
+            'channel': self.channel.to_dict() if isinstance(self.channel, TLObject) else self.channel,
+            'msg_id': self.msg_id,
+            'offset': self.offset,
+            'limit': self.limit
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'D\x01\x15_',
+            self.channel._bytes(),
+            struct.pack('<i', self.msg_id),
+            self.serialize_bytes(self.offset),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _channel = reader.tgread_object()
+        _msg_id = reader.read_int()
+        _offset = reader.tgread_string()
+        _limit = reader.read_int()
+        return cls(channel=_channel, msg_id=_msg_id, offset=_offset, limit=_limit)
+
+
+class GetMessageStatsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xb6e0a3f5
+    SUBCLASS_OF_ID = 0x9604a322
+
+    def __init__(self, channel: 'TypeInputChannel', msg_id: int, dark: Optional[bool]=None):
+        """
+        :returns stats.MessageStats: Instance of MessageStats.
+        """
+        self.channel = channel
+        self.msg_id = msg_id
+        self.dark = dark
+
+    async def resolve(self, client, utils):
+        self.channel = utils.get_input_channel(await client.get_input_entity(self.channel))
+
+    def to_dict(self):
+        return {
+            '_': 'GetMessageStatsRequest',
+            'channel': self.channel.to_dict() if isinstance(self.channel, TLObject) else self.channel,
+            'msg_id': self.msg_id,
+            'dark': self.dark
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xf5\xa3\xe0\xb6',
+            struct.pack('<I', (0 if self.dark is None or self.dark is False else 1)),
+            self.channel._bytes(),
+            struct.pack('<i', self.msg_id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _dark = bool(flags & 1)
+        _channel = reader.tgread_object()
+        _msg_id = reader.read_int()
+        return cls(channel=_channel, msg_id=_msg_id, dark=_dark)
+
+
+class GetStoryPublicForwardsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xa6437ef6
+    SUBCLASS_OF_ID = 0xa7283211
+
+    def __init__(self, peer: 'TypeInputPeer', id: int, offset: str, limit: int):
+        """
+        :returns stats.PublicForwards: Instance of PublicForwards.
+        """
+        self.peer = peer
+        self.id = id
+        self.offset = offset
+        self.limit = limit
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'GetStoryPublicForwardsRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer,
+            'id': self.id,
+            'offset': self.offset,
+            'limit': self.limit
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xf6~C\xa6',
+            self.peer._bytes(),
+            struct.pack('<i', self.id),
+            self.serialize_bytes(self.offset),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _peer = reader.tgread_object()
+        _id = reader.read_int()
+        _offset = reader.tgread_string()
+        _limit = reader.read_int()
+        return cls(peer=_peer, id=_id, offset=_offset, limit=_limit)
+
+
+class GetStoryStatsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x374fef40
+    SUBCLASS_OF_ID = 0x8b4d43d4
+
+    def __init__(self, peer: 'TypeInputPeer', id: int, dark: Optional[bool]=None):
+        """
+        :returns stats.StoryStats: Instance of StoryStats.
+        """
+        self.peer = peer
+        self.id = id
+        self.dark = dark
+
+    async def resolve(self, client, utils):
+        self.peer = utils.get_input_peer(await client.get_input_entity(self.peer))
+
+    def to_dict(self):
+        return {
+            '_': 'GetStoryStatsRequest',
+            'peer': self.peer.to_dict() if isinstance(self.peer, TLObject) else self.peer,
+            'id': self.id,
+            'dark': self.dark
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'@\xefO7',
+            struct.pack('<I', (0 if self.dark is None or self.dark is False else 1)),
+            self.peer._bytes(),
+            struct.pack('<i', self.id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _dark = bool(flags & 1)
+        _peer = reader.tgread_object()
+        _id = reader.read_int()
+        return cls(peer=_peer, id=_id, dark=_dark)
+
+
+class LoadAsyncGraphRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x621d5fa0
+    SUBCLASS_OF_ID = 0x9b903153
+
+    def __init__(self, token: str, x: Optional[int]=None):
+        """
+        :returns StatsGraph: Instance of either StatsGraphAsync, StatsGraphError, StatsGraph.
+        """
+        self.token = token
+        self.x = x
+
+    def to_dict(self):
+        return {
+            '_': 'LoadAsyncGraphRequest',
+            'token': self.token,
+            'x': self.x
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xa0_\x1db',
+            struct.pack('<I', (0 if self.x is None or self.x is False else 1)),
+            self.serialize_bytes(self.token),
+            b'' if self.x is None or self.x is False else (struct.pack('<q', self.x)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _token = reader.tgread_string()
+        if flags & 1:
+            _x = reader.read_long()
+        else:
+            _x = None
+        return cls(token=_token, x=_x)
+

.venv2/Lib/site-packages/telethon/tl/functions/stickers.py

@@ -0,0 +1,411 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputDocument, TypeInputStickerSet, TypeInputStickerSetItem, TypeInputUser, TypeMaskCoords
+
+
+
+class AddStickerToSetRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x8653febe
+    SUBCLASS_OF_ID = 0x9b704a5a
+
+    def __init__(self, stickerset: 'TypeInputStickerSet', sticker: 'TypeInputStickerSetItem'):
+        """
+        :returns messages.StickerSet: Instance of either StickerSet, StickerSetNotModified.
+        """
+        self.stickerset = stickerset
+        self.sticker = sticker
+
+    def to_dict(self):
+        return {
+            '_': 'AddStickerToSetRequest',
+            'stickerset': self.stickerset.to_dict() if isinstance(self.stickerset, TLObject) else self.stickerset,
+            'sticker': self.sticker.to_dict() if isinstance(self.sticker, TLObject) else self.sticker
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xbe\xfeS\x86',
+            self.stickerset._bytes(),
+            self.sticker._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _stickerset = reader.tgread_object()
+        _sticker = reader.tgread_object()
+        return cls(stickerset=_stickerset, sticker=_sticker)
+
+
+class ChangeStickerRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf5537ebc
+    SUBCLASS_OF_ID = 0x9b704a5a
+
+    def __init__(self, sticker: 'TypeInputDocument', emoji: Optional[str]=None, mask_coords: Optional['TypeMaskCoords']=None, keywords: Optional[str]=None):
+        """
+        :returns messages.StickerSet: Instance of either StickerSet, StickerSetNotModified.
+        """
+        self.sticker = sticker
+        self.emoji = emoji
+        self.mask_coords = mask_coords
+        self.keywords = keywords
+
+    async def resolve(self, client, utils):
+        self.sticker = utils.get_input_document(self.sticker)
+
+    def to_dict(self):
+        return {
+            '_': 'ChangeStickerRequest',
+            'sticker': self.sticker.to_dict() if isinstance(self.sticker, TLObject) else self.sticker,
+            'emoji': self.emoji,
+            'mask_coords': self.mask_coords.to_dict() if isinstance(self.mask_coords, TLObject) else self.mask_coords,
+            'keywords': self.keywords
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xbc~S\xf5',
+            struct.pack('<I', (0 if self.emoji is None or self.emoji is False else 1) | (0 if self.mask_coords is None or self.mask_coords is False else 2) | (0 if self.keywords is None or self.keywords is False else 4)),
+            self.sticker._bytes(),
+            b'' if self.emoji is None or self.emoji is False else (self.serialize_bytes(self.emoji)),
+            b'' if self.mask_coords is None or self.mask_coords is False else (self.mask_coords._bytes()),
+            b'' if self.keywords is None or self.keywords is False else (self.serialize_bytes(self.keywords)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _sticker = reader.tgread_object()
+        if flags & 1:
+            _emoji = reader.tgread_string()
+        else:
+            _emoji = None
+        if flags & 2:
+            _mask_coords = reader.tgread_object()
+        else:
+            _mask_coords = None
+        if flags & 4:
+            _keywords = reader.tgread_string()
+        else:
+            _keywords = None
+        return cls(sticker=_sticker, emoji=_emoji, mask_coords=_mask_coords, keywords=_keywords)
+
+
+class ChangeStickerPositionRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xffb6d4ca
+    SUBCLASS_OF_ID = 0x9b704a5a
+
+    def __init__(self, sticker: 'TypeInputDocument', position: int):
+        """
+        :returns messages.StickerSet: Instance of either StickerSet, StickerSetNotModified.
+        """
+        self.sticker = sticker
+        self.position = position
+
+    async def resolve(self, client, utils):
+        self.sticker = utils.get_input_document(self.sticker)
+
+    def to_dict(self):
+        return {
+            '_': 'ChangeStickerPositionRequest',
+            'sticker': self.sticker.to_dict() if isinstance(self.sticker, TLObject) else self.sticker,
+            'position': self.position
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xca\xd4\xb6\xff',
+            self.sticker._bytes(),
+            struct.pack('<i', self.position),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _sticker = reader.tgread_object()
+        _position = reader.read_int()
+        return cls(sticker=_sticker, position=_position)
+
+
+class CheckShortNameRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x284b3639
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, short_name: str):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.short_name = short_name
+
+    def to_dict(self):
+        return {
+            '_': 'CheckShortNameRequest',
+            'short_name': self.short_name
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'96K(',
+            self.serialize_bytes(self.short_name),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _short_name = reader.tgread_string()
+        return cls(short_name=_short_name)
+
+
+class CreateStickerSetRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9021ab67
+    SUBCLASS_OF_ID = 0x9b704a5a
+
+    def __init__(self, user_id: 'TypeInputUser', title: str, short_name: str, stickers: List['TypeInputStickerSetItem'], masks: Optional[bool]=None, animated: Optional[bool]=None, videos: Optional[bool]=None, emojis: Optional[bool]=None, text_color: Optional[bool]=None, thumb: Optional['TypeInputDocument']=None, software: Optional[str]=None):
+        """
+        :returns messages.StickerSet: Instance of either StickerSet, StickerSetNotModified.
+        """
+        self.user_id = user_id
+        self.title = title
+        self.short_name = short_name
+        self.stickers = stickers
+        self.masks = masks
+        self.animated = animated
+        self.videos = videos
+        self.emojis = emojis
+        self.text_color = text_color
+        self.thumb = thumb
+        self.software = software
+
+    async def resolve(self, client, utils):
+        self.user_id = utils.get_input_user(await client.get_input_entity(self.user_id))
+        if self.thumb:
+            self.thumb = utils.get_input_document(self.thumb)
+
+    def to_dict(self):
+        return {
+            '_': 'CreateStickerSetRequest',
+            'user_id': self.user_id.to_dict() if isinstance(self.user_id, TLObject) else self.user_id,
+            'title': self.title,
+            'short_name': self.short_name,
+            'stickers': [] if self.stickers is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.stickers],
+            'masks': self.masks,
+            'animated': self.animated,
+            'videos': self.videos,
+            'emojis': self.emojis,
+            'text_color': self.text_color,
+            'thumb': self.thumb.to_dict() if isinstance(self.thumb, TLObject) else self.thumb,
+            'software': self.software
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'g\xab!\x90',
+            struct.pack('<I', (0 if self.masks is None or self.masks is False else 1) | (0 if self.animated is None or self.animated is False else 2) | (0 if self.videos is None or self.videos is False else 16) | (0 if self.emojis is None or self.emojis is False else 32) | (0 if self.text_color is None or self.text_color is False else 64) | (0 if self.thumb is None or self.thumb is False else 4) | (0 if self.software is None or self.software is False else 8)),
+            self.user_id._bytes(),
+            self.serialize_bytes(self.title),
+            self.serialize_bytes(self.short_name),
+            b'' if self.thumb is None or self.thumb is False else (self.thumb._bytes()),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.stickers)),b''.join(x._bytes() for x in self.stickers),
+            b'' if self.software is None or self.software is False else (self.serialize_bytes(self.software)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _masks = bool(flags & 1)
+        _animated = bool(flags & 2)
+        _videos = bool(flags & 16)
+        _emojis = bool(flags & 32)
+        _text_color = bool(flags & 64)
+        _user_id = reader.tgread_object()
+        _title = reader.tgread_string()
+        _short_name = reader.tgread_string()
+        if flags & 4:
+            _thumb = reader.tgread_object()
+        else:
+            _thumb = None
+        reader.read_int()
+        _stickers = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _stickers.append(_x)
+
+        if flags & 8:
+            _software = reader.tgread_string()
+        else:
+            _software = None
+        return cls(user_id=_user_id, title=_title, short_name=_short_name, stickers=_stickers, masks=_masks, animated=_animated, videos=_videos, emojis=_emojis, text_color=_text_color, thumb=_thumb, software=_software)
+
+
+class DeleteStickerSetRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x87704394
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, stickerset: 'TypeInputStickerSet'):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.stickerset = stickerset
+
+    def to_dict(self):
+        return {
+            '_': 'DeleteStickerSetRequest',
+            'stickerset': self.stickerset.to_dict() if isinstance(self.stickerset, TLObject) else self.stickerset
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x94Cp\x87',
+            self.stickerset._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _stickerset = reader.tgread_object()
+        return cls(stickerset=_stickerset)
+
+
+class RemoveStickerFromSetRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xf7760f51
+    SUBCLASS_OF_ID = 0x9b704a5a
+
+    def __init__(self, sticker: 'TypeInputDocument'):
+        """
+        :returns messages.StickerSet: Instance of either StickerSet, StickerSetNotModified.
+        """
+        self.sticker = sticker
+
+    async def resolve(self, client, utils):
+        self.sticker = utils.get_input_document(self.sticker)
+
+    def to_dict(self):
+        return {
+            '_': 'RemoveStickerFromSetRequest',
+            'sticker': self.sticker.to_dict() if isinstance(self.sticker, TLObject) else self.sticker
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'Q\x0fv\xf7',
+            self.sticker._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _sticker = reader.tgread_object()
+        return cls(sticker=_sticker)
+
+
+class RenameStickerSetRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x124b1c00
+    SUBCLASS_OF_ID = 0x9b704a5a
+
+    def __init__(self, stickerset: 'TypeInputStickerSet', title: str):
+        """
+        :returns messages.StickerSet: Instance of either StickerSet, StickerSetNotModified.
+        """
+        self.stickerset = stickerset
+        self.title = title
+
+    def to_dict(self):
+        return {
+            '_': 'RenameStickerSetRequest',
+            'stickerset': self.stickerset.to_dict() if isinstance(self.stickerset, TLObject) else self.stickerset,
+            'title': self.title
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x00\x1cK\x12',
+            self.stickerset._bytes(),
+            self.serialize_bytes(self.title),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _stickerset = reader.tgread_object()
+        _title = reader.tgread_string()
+        return cls(stickerset=_stickerset, title=_title)
+
+
+class SetStickerSetThumbRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xa76a5392
+    SUBCLASS_OF_ID = 0x9b704a5a
+
+    def __init__(self, stickerset: 'TypeInputStickerSet', thumb: Optional['TypeInputDocument']=None, thumb_document_id: Optional[int]=None):
+        """
+        :returns messages.StickerSet: Instance of either StickerSet, StickerSetNotModified.
+        """
+        self.stickerset = stickerset
+        self.thumb = thumb
+        self.thumb_document_id = thumb_document_id
+
+    async def resolve(self, client, utils):
+        if self.thumb:
+            self.thumb = utils.get_input_document(self.thumb)
+
+    def to_dict(self):
+        return {
+            '_': 'SetStickerSetThumbRequest',
+            'stickerset': self.stickerset.to_dict() if isinstance(self.stickerset, TLObject) else self.stickerset,
+            'thumb': self.thumb.to_dict() if isinstance(self.thumb, TLObject) else self.thumb,
+            'thumb_document_id': self.thumb_document_id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x92Sj\xa7',
+            struct.pack('<I', (0 if self.thumb is None or self.thumb is False else 1) | (0 if self.thumb_document_id is None or self.thumb_document_id is False else 2)),
+            self.stickerset._bytes(),
+            b'' if self.thumb is None or self.thumb is False else (self.thumb._bytes()),
+            b'' if self.thumb_document_id is None or self.thumb_document_id is False else (struct.pack('<q', self.thumb_document_id)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _stickerset = reader.tgread_object()
+        if flags & 1:
+            _thumb = reader.tgread_object()
+        else:
+            _thumb = None
+        if flags & 2:
+            _thumb_document_id = reader.read_long()
+        else:
+            _thumb_document_id = None
+        return cls(stickerset=_stickerset, thumb=_thumb, thumb_document_id=_thumb_document_id)
+
+
+class SuggestShortNameRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x4dafc503
+    SUBCLASS_OF_ID = 0xc44a4b21
+
+    def __init__(self, title: str):
+        """
+        :returns stickers.SuggestedShortName: Instance of SuggestedShortName.
+        """
+        self.title = title
+
+    def to_dict(self):
+        return {
+            '_': 'SuggestShortNameRequest',
+            'title': self.title
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x03\xc5\xafM',
+            self.serialize_bytes(self.title),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _title = reader.tgread_string()
+        return cls(title=_title)
+

.venv2/Lib/site-packages/telethon/tl/functions/updates.py

@@ -0,0 +1,139 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeChannelMessagesFilter, TypeInputChannel
+
+
+
+class GetChannelDifferenceRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x3173d78
+    SUBCLASS_OF_ID = 0x29896f5d
+
+    def __init__(self, channel: 'TypeInputChannel', filter: 'TypeChannelMessagesFilter', pts: int, limit: int, force: Optional[bool]=None):
+        """
+        :returns updates.ChannelDifference: Instance of either ChannelDifferenceEmpty, ChannelDifferenceTooLong, ChannelDifference.
+        """
+        self.channel = channel
+        self.filter = filter
+        self.pts = pts
+        self.limit = limit
+        self.force = force
+
+    async def resolve(self, client, utils):
+        self.channel = utils.get_input_channel(await client.get_input_entity(self.channel))
+
+    def to_dict(self):
+        return {
+            '_': 'GetChannelDifferenceRequest',
+            'channel': self.channel.to_dict() if isinstance(self.channel, TLObject) else self.channel,
+            'filter': self.filter.to_dict() if isinstance(self.filter, TLObject) else self.filter,
+            'pts': self.pts,
+            'limit': self.limit,
+            'force': self.force
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'x=\x17\x03',
+            struct.pack('<I', (0 if self.force is None or self.force is False else 1)),
+            self.channel._bytes(),
+            self.filter._bytes(),
+            struct.pack('<i', self.pts),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _force = bool(flags & 1)
+        _channel = reader.tgread_object()
+        _filter = reader.tgread_object()
+        _pts = reader.read_int()
+        _limit = reader.read_int()
+        return cls(channel=_channel, filter=_filter, pts=_pts, limit=_limit, force=_force)
+
+
+class GetDifferenceRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x19c2f763
+    SUBCLASS_OF_ID = 0x20482874
+
+    def __init__(self, pts: int, date: Optional[datetime], qts: int, pts_limit: Optional[int]=None, pts_total_limit: Optional[int]=None, qts_limit: Optional[int]=None):
+        """
+        :returns updates.Difference: Instance of either DifferenceEmpty, Difference, DifferenceSlice, DifferenceTooLong.
+        """
+        self.pts = pts
+        self.date = date
+        self.qts = qts
+        self.pts_limit = pts_limit
+        self.pts_total_limit = pts_total_limit
+        self.qts_limit = qts_limit
+
+    def to_dict(self):
+        return {
+            '_': 'GetDifferenceRequest',
+            'pts': self.pts,
+            'date': self.date,
+            'qts': self.qts,
+            'pts_limit': self.pts_limit,
+            'pts_total_limit': self.pts_total_limit,
+            'qts_limit': self.qts_limit
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'c\xf7\xc2\x19',
+            struct.pack('<I', (0 if self.pts_limit is None or self.pts_limit is False else 2) | (0 if self.pts_total_limit is None or self.pts_total_limit is False else 1) | (0 if self.qts_limit is None or self.qts_limit is False else 4)),
+            struct.pack('<i', self.pts),
+            b'' if self.pts_limit is None or self.pts_limit is False else (struct.pack('<i', self.pts_limit)),
+            b'' if self.pts_total_limit is None or self.pts_total_limit is False else (struct.pack('<i', self.pts_total_limit)),
+            self.serialize_datetime(self.date),
+            struct.pack('<i', self.qts),
+            b'' if self.qts_limit is None or self.qts_limit is False else (struct.pack('<i', self.qts_limit)),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _pts = reader.read_int()
+        if flags & 2:
+            _pts_limit = reader.read_int()
+        else:
+            _pts_limit = None
+        if flags & 1:
+            _pts_total_limit = reader.read_int()
+        else:
+            _pts_total_limit = None
+        _date = reader.tgread_date()
+        _qts = reader.read_int()
+        if flags & 4:
+            _qts_limit = reader.read_int()
+        else:
+            _qts_limit = None
+        return cls(pts=_pts, date=_date, qts=_qts, pts_limit=_pts_limit, pts_total_limit=_pts_total_limit, qts_limit=_qts_limit)
+
+
+class GetStateRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xedd4882a
+    SUBCLASS_OF_ID = 0x23df1a01
+
+    def to_dict(self):
+        return {
+            '_': 'GetStateRequest'
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'*\x88\xd4\xed',
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        return cls()
+

.venv2/Lib/site-packages/telethon/tl/functions/upload.py

@@ -0,0 +1,300 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputFileLocation, TypeInputWebFileLocation
+
+
+
+class GetCdnFileRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x395f69da
+    SUBCLASS_OF_ID = 0xf5ccf928
+
+    def __init__(self, file_token: bytes, offset: int, limit: int):
+        """
+        :returns upload.CdnFile: Instance of either CdnFileReuploadNeeded, CdnFile.
+        """
+        self.file_token = file_token
+        self.offset = offset
+        self.limit = limit
+
+    def to_dict(self):
+        return {
+            '_': 'GetCdnFileRequest',
+            'file_token': self.file_token,
+            'offset': self.offset,
+            'limit': self.limit
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xdai_9',
+            self.serialize_bytes(self.file_token),
+            struct.pack('<q', self.offset),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _file_token = reader.tgread_bytes()
+        _offset = reader.read_long()
+        _limit = reader.read_int()
+        return cls(file_token=_file_token, offset=_offset, limit=_limit)
+
+
+class GetCdnFileHashesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x91dc3f31
+    SUBCLASS_OF_ID = 0xa5940726
+
+    def __init__(self, file_token: bytes, offset: int):
+        """
+        :returns Vector<FileHash>: This type has no constructors.
+        """
+        self.file_token = file_token
+        self.offset = offset
+
+    def to_dict(self):
+        return {
+            '_': 'GetCdnFileHashesRequest',
+            'file_token': self.file_token,
+            'offset': self.offset
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'1?\xdc\x91',
+            self.serialize_bytes(self.file_token),
+            struct.pack('<q', self.offset),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _file_token = reader.tgread_bytes()
+        _offset = reader.read_long()
+        return cls(file_token=_file_token, offset=_offset)
+
+
+class GetFileRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xbe5335be
+    SUBCLASS_OF_ID = 0x6c9bd728
+
+    def __init__(self, location: 'TypeInputFileLocation', offset: int, limit: int, precise: Optional[bool]=None, cdn_supported: Optional[bool]=None):
+        """
+        :returns upload.File: Instance of either File, FileCdnRedirect.
+        """
+        self.location = location
+        self.offset = offset
+        self.limit = limit
+        self.precise = precise
+        self.cdn_supported = cdn_supported
+
+    def to_dict(self):
+        return {
+            '_': 'GetFileRequest',
+            'location': self.location.to_dict() if isinstance(self.location, TLObject) else self.location,
+            'offset': self.offset,
+            'limit': self.limit,
+            'precise': self.precise,
+            'cdn_supported': self.cdn_supported
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xbe5S\xbe',
+            struct.pack('<I', (0 if self.precise is None or self.precise is False else 1) | (0 if self.cdn_supported is None or self.cdn_supported is False else 2)),
+            self.location._bytes(),
+            struct.pack('<q', self.offset),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        flags = reader.read_int()
+
+        _precise = bool(flags & 1)
+        _cdn_supported = bool(flags & 2)
+        _location = reader.tgread_object()
+        _offset = reader.read_long()
+        _limit = reader.read_int()
+        return cls(location=_location, offset=_offset, limit=_limit, precise=_precise, cdn_supported=_cdn_supported)
+
+
+class GetFileHashesRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9156982a
+    SUBCLASS_OF_ID = 0xa5940726
+
+    def __init__(self, location: 'TypeInputFileLocation', offset: int):
+        """
+        :returns Vector<FileHash>: This type has no constructors.
+        """
+        self.location = location
+        self.offset = offset
+
+    def to_dict(self):
+        return {
+            '_': 'GetFileHashesRequest',
+            'location': self.location.to_dict() if isinstance(self.location, TLObject) else self.location,
+            'offset': self.offset
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'*\x98V\x91',
+            self.location._bytes(),
+            struct.pack('<q', self.offset),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _location = reader.tgread_object()
+        _offset = reader.read_long()
+        return cls(location=_location, offset=_offset)
+
+
+class GetWebFileRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x24e6818d
+    SUBCLASS_OF_ID = 0x68f17f51
+
+    def __init__(self, location: 'TypeInputWebFileLocation', offset: int, limit: int):
+        """
+        :returns upload.WebFile: Instance of WebFile.
+        """
+        self.location = location
+        self.offset = offset
+        self.limit = limit
+
+    def to_dict(self):
+        return {
+            '_': 'GetWebFileRequest',
+            'location': self.location.to_dict() if isinstance(self.location, TLObject) else self.location,
+            'offset': self.offset,
+            'limit': self.limit
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x8d\x81\xe6$',
+            self.location._bytes(),
+            struct.pack('<i', self.offset),
+            struct.pack('<i', self.limit),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _location = reader.tgread_object()
+        _offset = reader.read_int()
+        _limit = reader.read_int()
+        return cls(location=_location, offset=_offset, limit=_limit)
+
+
+class ReuploadCdnFileRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x9b2754a8
+    SUBCLASS_OF_ID = 0xa5940726
+
+    def __init__(self, file_token: bytes, request_token: bytes):
+        """
+        :returns Vector<FileHash>: This type has no constructors.
+        """
+        self.file_token = file_token
+        self.request_token = request_token
+
+    def to_dict(self):
+        return {
+            '_': 'ReuploadCdnFileRequest',
+            'file_token': self.file_token,
+            'request_token': self.request_token
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b"\xa8T'\x9b",
+            self.serialize_bytes(self.file_token),
+            self.serialize_bytes(self.request_token),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _file_token = reader.tgread_bytes()
+        _request_token = reader.tgread_bytes()
+        return cls(file_token=_file_token, request_token=_request_token)
+
+
+class SaveBigFilePartRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xde7b673d
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, file_id: int, file_part: int, file_total_parts: int, bytes: bytes):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.file_id = file_id
+        self.file_part = file_part
+        self.file_total_parts = file_total_parts
+        self.bytes = bytes
+
+    def to_dict(self):
+        return {
+            '_': 'SaveBigFilePartRequest',
+            'file_id': self.file_id,
+            'file_part': self.file_part,
+            'file_total_parts': self.file_total_parts,
+            'bytes': self.bytes
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'=g{\xde',
+            struct.pack('<q', self.file_id),
+            struct.pack('<i', self.file_part),
+            struct.pack('<i', self.file_total_parts),
+            self.serialize_bytes(self.bytes),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _file_id = reader.read_long()
+        _file_part = reader.read_int()
+        _file_total_parts = reader.read_int()
+        _bytes = reader.tgread_bytes()
+        return cls(file_id=_file_id, file_part=_file_part, file_total_parts=_file_total_parts, bytes=_bytes)
+
+
+class SaveFilePartRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xb304a621
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, file_id: int, file_part: int, bytes: bytes):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.file_id = file_id
+        self.file_part = file_part
+        self.bytes = bytes
+
+    def to_dict(self):
+        return {
+            '_': 'SaveFilePartRequest',
+            'file_id': self.file_id,
+            'file_part': self.file_part,
+            'bytes': self.bytes
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'!\xa6\x04\xb3',
+            struct.pack('<q', self.file_id),
+            struct.pack('<i', self.file_part),
+            self.serialize_bytes(self.bytes),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _file_id = reader.read_long()
+        _file_part = reader.read_int()
+        _bytes = reader.tgread_bytes()
+        return cls(file_id=_file_id, file_part=_file_part, bytes=_bytes)
+

.venv2/Lib/site-packages/telethon/tl/functions/users.py

@@ -0,0 +1,162 @@
+"""File generated by TLObjects' generator. All changes will be ERASED"""
+from ...tl.tlobject import TLObject
+from ...tl.tlobject import TLRequest
+from typing import Optional, List, Union, TYPE_CHECKING
+import os
+import struct
+from datetime import datetime
+if TYPE_CHECKING:
+    from ...tl.types import TypeInputUser, TypeSecureValueError
+
+
+
+class GetFullUserRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xb60f5918
+    SUBCLASS_OF_ID = 0x83df9df5
+
+    def __init__(self, id: 'TypeInputUser'):
+        """
+        :returns users.UserFull: Instance of UserFull.
+        """
+        self.id = id
+
+    async def resolve(self, client, utils):
+        self.id = utils.get_input_user(await client.get_input_entity(self.id))
+
+    def to_dict(self):
+        return {
+            '_': 'GetFullUserRequest',
+            'id': self.id.to_dict() if isinstance(self.id, TLObject) else self.id
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x18Y\x0f\xb6',
+            self.id._bytes(),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _id = reader.tgread_object()
+        return cls(id=_id)
+
+
+class GetIsPremiumRequiredToContactRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xa622aa10
+    SUBCLASS_OF_ID = 0x15dfc3f1
+
+    def __init__(self, id: List['TypeInputUser']):
+        """
+        :returns Vector<Bool>: This type has no constructors.
+        """
+        self.id = id
+
+    async def resolve(self, client, utils):
+        _tmp = []
+        for _x in self.id:
+            _tmp.append(utils.get_input_user(await client.get_input_entity(_x)))
+
+        self.id = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'GetIsPremiumRequiredToContactRequest',
+            'id': [] if self.id is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.id]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\x10\xaa"\xa6',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.id)),b''.join(x._bytes() for x in self.id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _id = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _id.append(_x)
+
+        return cls(id=_id)
+
+
+class GetUsersRequest(TLRequest):
+    CONSTRUCTOR_ID = 0xd91a548
+    SUBCLASS_OF_ID = 0x406da4d
+
+    def __init__(self, id: List['TypeInputUser']):
+        """
+        :returns Vector<User>: This type has no constructors.
+        """
+        self.id = id
+
+    async def resolve(self, client, utils):
+        _tmp = []
+        for _x in self.id:
+            _tmp.append(utils.get_input_user(await client.get_input_entity(_x)))
+
+        self.id = _tmp
+
+    def to_dict(self):
+        return {
+            '_': 'GetUsersRequest',
+            'id': [] if self.id is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.id]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'H\xa5\x91\r',
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.id)),b''.join(x._bytes() for x in self.id),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        reader.read_int()
+        _id = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _id.append(_x)
+
+        return cls(id=_id)
+
+
+class SetSecureValueErrorsRequest(TLRequest):
+    CONSTRUCTOR_ID = 0x90c894b5
+    SUBCLASS_OF_ID = 0xf5b399ac
+
+    def __init__(self, id: 'TypeInputUser', errors: List['TypeSecureValueError']):
+        """
+        :returns Bool: This type has no constructors.
+        """
+        self.id = id
+        self.errors = errors
+
+    async def resolve(self, client, utils):
+        self.id = utils.get_input_user(await client.get_input_entity(self.id))
+
+    def to_dict(self):
+        return {
+            '_': 'SetSecureValueErrorsRequest',
+            'id': self.id.to_dict() if isinstance(self.id, TLObject) else self.id,
+            'errors': [] if self.errors is None else [x.to_dict() if isinstance(x, TLObject) else x for x in self.errors]
+        }
+
+    def _bytes(self):
+        return b''.join((
+            b'\xb5\x94\xc8\x90',
+            self.id._bytes(),
+            b'\x15\xc4\xb5\x1c',struct.pack('<i', len(self.errors)),b''.join(x._bytes() for x in self.errors),
+        ))
+
+    @classmethod
+    def from_reader(cls, reader):
+        _id = reader.tgread_object()
+        reader.read_int()
+        _errors = []
+        for _ in range(reader.read_int()):
+            _x = reader.tgread_object()
+            _errors.append(_x)
+
+        return cls(id=_id, errors=_errors)
+