docs: async def send_message(
              self, entity, message='', *, reply_to=None,
              parse_mode=(), link_preview=True, file=None,
              force_document=False, clear_draft=False, buttons=None,
              silent=None):
          """
          Sends the given message to the specified entity (user/chat/channel).
  
          The default parse mode is the same as the official applications
          (a custom flavour of markdown). ``**bold**, `code` or __italic__``
          are available. In addition you can send ``[links](https://example.com)``
          and ``[mentions](@username)`` (or using IDs like in the Bot API:
          ``[mention](tg://user?id=123456789)``) and ``pre`` blocks with three
          backticks.
  
          Sending a ``/start`` command with a parameter (like ``?start=data``)
          is also done through this method. Simply send ``'/start data'`` to
          the bot.
  
          Args:
              entity (`entity`):
                  To who will it be sent.
  
              message (`str` | `Message <telethon.tl.custom.message.Message>`):
                  The message to be sent, or another message object to resend.
  
                  The maximum length for a message is 35,000 bytes or 4,096
                  characters. Longer messages will not be sliced automatically,
                  and you should slice them manually if the text to send is
                  longer than said length.
  
              reply_to (`int` | `Message <telethon.tl.custom.message.Message>`, optional):
                  Whether to reply to a message or not. If an integer is provided,
                  it should be the ID of the message that it should reply to.
  
              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 (`file`, optional):
                  Sends a message with a file attached (e.g. a photo,
                  video, audio or document). The ``message`` may be empty.
  
              force_document (`bool`, optional):
                  Whether to send the given file as a document or not.
  
              clear_draft (`bool`, optional):
                  Whether the existing draft should be cleared or not.
                  Has no effect when sending a file.
  
              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.
  
                  All the following limits apply together:
  
                  * There can be 100 buttons at most (any more are ignored).
                  * There can be 8 buttons per row at most (more are ignored).
                  * The maximum callback data per button is 64 bytes.
                  * The maximum data that can be embedded in total is just
                    over 4KB, shared between inline callback data and text.
  
              silent (`bool`, optional):
                  Whether the message should notify people in a broadcast
                  channel or not. Defaults to ``False``, which means it will
                  notify them. Set it to ``True`` to alter this behaviour.
  
          Returns:
              The sent `custom.Message <telethon.tl.custom.message.Message>`.
          """
          if file is not None:
              return await self.send_file(
                  entity, file, caption=message, reply_to=reply_to,
                  parse_mode=parse_mode, force_document=force_document,
                  buttons=buttons
              )
          elif not message:
              raise ValueError(
                  'The message cannot be empty unless a file is provided'
              )
  
          entity = await self.get_input_entity(entity)
          if isinstance(message, types.Message):
              if buttons is None:
                  markup = message.reply_markup
              else:
                  markup = self.build_reply_markup(buttons)
  
              if silent is None:
                  silent = message.silent
  
              if (message.media and not isinstance(
                      message.media, types.MessageMediaWebPage)):
                  return await self.send_file(
                      entity,
                      message.media,
                      caption=message.message,
                      silent=silent,
                      reply_to=reply_to,
                      buttons=markup,
                      entities=message.entities
                  )
  
              request = functions.messages.SendMessageRequest(
                  peer=entity,
                  message=message.message or '',
                  silent=silent,
                  reply_to_msg_id=utils.get_message_id(reply_to),
                  reply_markup=markup,
                  entities=message.entities,
                  clear_draft=clear_draft,
                  no_webpage=not isinstance(
                      message.media, types.MessageMediaWebPage)
              )
              message = message.message
          else:
              message, msg_ent = await self._parse_message_text(message,
                                                                parse_mode)
              request = functions.messages.SendMessageRequest(
                  peer=entity,
                  message=message,
                  entities=msg_ent,
                  no_webpage=not link_preview,
                  reply_to_msg_id=utils.get_message_id(reply_to),
                  clear_draft=clear_draft,
                  silent=silent,
                  reply_markup=self.build_reply_markup(buttons)
              )
  
          result = await self(request)
          if isinstance(result, types.UpdateShortSentMessage):
              message = types.Message(
                  id=result.id,
                  to_id=utils.get_peer(entity),
                  message=message,
                  date=result.date,
                  out=result.out,
                  media=result.media,
                  entities=result.entities,
                  reply_markup=request.reply_markup
              )
              message._finish_init(self, {}, entity)
              return message
  
          return self._get_response_message(request, result, entity)