docs: async def edit_message(
              self, entity, message=None, text=None,
              *, parse_mode=(), link_preview=True, file=None,
              buttons=None):
          """
          Edits the given message ID (to change its contents or disable preview).
  
          Args:
              entity (`entity` | `Message <telethon.tl.custom.message.Message>`):
                  From which chat to edit the message. This can also be
                  the message to be edited, and the entity will be inferred
                  from it, so the next parameter will be assumed to be the
                  message text.
  
                  You may also pass a :tl:`InputBotInlineMessageID`,
                  which is the only way to edit messages that were sent
                  after the user selects an inline query result.
  
              message (`int` | `Message <telethon.tl.custom.message.Message>` | `str`):
                  The ID of the message (or `Message
                  <telethon.tl.custom.message.Message>` itself) to be edited.
                  If the `entity` was a `Message
                  <telethon.tl.custom.message.Message>`, then this message
                  will be treated as the new text.
  
              text (`str`, optional):
                  The new text of the message. Does nothing if the `entity`
                  was a `Message <telethon.tl.custom.message.Message>`.
  
              parse_mode (`object`, optional):
                  See the `TelegramClient.parse_mode
                  <telethon.client.messageparse.MessageParseMethods.parse_mode>`
                  property for allowed values. Markdown parsing will be used by
                  default.
  
              link_preview (`bool`, optional):
                  Should the link preview be shown?
  
              file (`str` | `bytes` | `file` | `media`, optional):
                  The file object that should replace the existing media
                  in the message.
  
              buttons (`list`, `custom.Button <telethon.tl.custom.button.Button>`, :tl:`KeyboardButton`):
                  The matrix (list of lists), row list or button to be shown
                  after sending the message. This parameter will only work if
                  you have signed in as a bot. You can also pass your own
                  :tl:`ReplyMarkup` here.
  
          Examples:
  
              >>> client = ...
              >>> message = client.send_message('username', 'hello')
              >>>
              >>> client.edit_message('username', message, 'hello!')
              >>> # or
              >>> client.edit_message('username', message.id, 'Hello')
              >>> # or
              >>> client.edit_message(message, 'Hello!')
  
          Raises:
              ``MessageAuthorRequiredError`` if you're not the author of the
              message but tried editing it anyway.
  
              ``MessageNotModifiedError`` if the contents of the message were
              not modified at all.
  
          Returns:
              The edited `telethon.tl.custom.message.Message`, unless
              `entity` was a :tl:`InputBotInlineMessageID` in which
              case this method returns a boolean.
          """
          if isinstance(entity, types.InputBotInlineMessageID):
              text = message
              message = entity
          elif isinstance(entity, types.Message):
              text = message  # Shift the parameters to the right
              message = entity
              entity = entity.to_id
  
          text, msg_entities = await self._parse_message_text(text, parse_mode)
          file_handle, media, image = await self._file_to_media(file)
  
          if isinstance(entity, types.InputBotInlineMessageID):
              return await self(functions.messages.EditInlineBotMessageRequest(
                  id=entity,
                  message=text,
                  no_webpage=not link_preview,
                  entities=msg_entities,
                  media=media,
                  reply_markup=self.build_reply_markup(buttons)
              ))
  
          entity = await self.get_input_entity(entity)
          request = functions.messages.EditMessageRequest(
              peer=entity,
              id=utils.get_message_id(message),
              message=text,
              no_webpage=not link_preview,
              entities=msg_entities,
              media=media,
              reply_markup=self.build_reply_markup(buttons)
          )
          msg = self._get_response_message(request, await self(request), entity)
          await self._cache_media(msg, file, file_handle, image=image)
          return msg