diff --git a/telethon/_client/telegramclient.py b/telethon/_client/telegramclient.py
index a4958fe2..66673b73 100644
--- a/telethon/_client/telegramclient.py
+++ b/telethon/_client/telegramclient.py
@@ -3329,85 +3329,6 @@ class TelegramClient:
                 some_id = await client.get_peer_id('+34123456789')
         """
 
-    @forward_call(users.get_input_entity)
-    async def get_input_entity(
-            self: 'TelegramClient',
-            peer: 'hints.EntityLike') -> '_tl.TypeInputPeer':
-        """
-        Turns the given entity into its input entity version.
-
-        Most requests use this kind of :tl:`InputPeer`, so this is the most
-        suitable call to make for those cases. **Generally you should let the
-        library do its job** and don't worry about getting the input entity
-        first, but if you're going to use an entity often, consider making the
-        call:
-
-        Arguments
-            entity (`str` | `int` | :tl:`Peer` | :tl:`InputPeer`):
-                If a username or invite link is given, **the library will
-                use the cache**. This means that it's possible to be using
-                a username that *changed* or an old invite link (this only
-                happens if an invite link for a small group chat is used
-                after it was upgraded to a mega-group).
-
-                If the username or ID from the invite link is not found in
-                the cache, it will be fetched. The same rules apply to phone
-                numbers (``'+34 123456789'``) from people in your contact list.
-
-                If an exact name is given, it must be in the cache too. This
-                is not reliable as different people can share the same name
-                and which entity is returned is arbitrary, and should be used
-                only for quick tests.
-
-                If a positive integer ID is given, the entity will be searched
-                in cached users, chats or channels, without making any call.
-
-                If a negative integer ID is given, the entity will be searched
-                exactly as either a chat (prefixed with ``-``) or as a channel
-                (prefixed with ``-100``).
-
-                If a :tl:`Peer` is given, it will be searched exactly in the
-                cache as either a user, chat or channel.
-
-                If the given object can be turned into an input entity directly,
-                said operation will be done.
-
-                Unsupported types will raise ``TypeError``.
-
-                If the entity can't be found, ``ValueError`` will be raised.
-
-        Returns
-            :tl:`InputPeerUser`, :tl:`InputPeerChat` or :tl:`InputPeerChannel`
-            or :tl:`InputPeerSelf` if the parameter is ``'me'`` or ``'self'``.
-
-        Example
-            .. code-block:: python
-
-                # If you're going to use "username" often in your code
-                # (make a lot of calls), consider getting its input entity
-                # once, and then using the "user" everywhere instead.
-                user = await client.get_input_entity('username')
-
-                # The same applies to IDs, chats or channels.
-                chat = await client.get_input_entity(-123456789)
-        """
-
-    @forward_call(users.get_peer_id)
-    async def get_peer_id(
-            self: 'TelegramClient',
-            peer: 'hints.EntityLike') -> int:
-        """
-        Gets the ID for the given entity.
-
-        This method needs to be ``async`` because `peer` supports usernames,
-        invite-links, phone numbers (from people in your contact list), etc.
-
-        Example
-            .. code-block:: python
-
-                print(await client.get_peer_id('me'))
-        """
-
     # endregion Users
 
     # region Private