docs: def iter_messages(
              self, entity, limit=None, *, offset_date=None, offset_id=0,
              max_id=0, min_id=0, add_offset=0, search=None, filter=None,
              from_user=None, wait_time=None, ids=None, reverse=False
      ):
          """
          Iterator over the message history for the specified entity.
          If either `search`, `filter` or `from_user` are provided,
          :tl:`messages.Search` will be used instead of :tl:`messages.getHistory`.
  
          Args:
              entity (`entity`):
                  The entity from whom to retrieve the message history.
  
                  It may be ``None`` to perform a global search, or
                  to get messages by their ID from no particular chat.
                  Note that some of the offsets will not work if this
                  is the case.
  
                  Note that if you want to perform a global search,
                  you **must** set a non-empty `search` string.
  
              limit (`int` | `None`, optional):
                  Number of messages to be retrieved. Due to limitations with
                  the API retrieving more than 3000 messages will take longer
                  than half a minute (or even more based on previous calls).
  
                  The limit may also be ``None``, which would eventually return
                  the whole history.
  
              offset_date (`datetime`):
                  Offset date (messages *previous* to this date will be
                  retrieved). Exclusive.
  
              offset_id (`int`):
                  Offset message ID (only messages *previous* to the given
                  ID will be retrieved). Exclusive.
  
              max_id (`int`):
                  All the messages with a higher (newer) ID or equal to this will
                  be excluded.
  
              min_id (`int`):
                  All the messages with a lower (older) ID or equal to this will
                  be excluded.
  
              add_offset (`int`):
                  Additional message offset (all of the specified offsets +
                  this offset = older messages).
  
              search (`str`):
                  The string to be used as a search query.
  
              filter (:tl:`MessagesFilter` | `type`):
                  The filter to use when returning messages. For instance,
                  :tl:`InputMessagesFilterPhotos` would yield only messages
                  containing photos.
  
              from_user (`entity`):
                  Only messages from this user will be returned.
                  This parameter will be ignored if it is not an user.
  
              wait_time (`int`):
                  Wait time (in seconds) between different
                  :tl:`GetHistoryRequest`. Use this parameter to avoid hitting
                  the ``FloodWaitError`` as needed. If left to ``None``, it will
                  default to 1 second only if the limit is higher than 3000.
  
              ids (`int`, `list`):
                  A single integer ID (or several IDs) for the message that
                  should be returned. This parameter takes precedence over
                  the rest (which will be ignored if this is set). This can
                  for instance be used to get the message with ID 123 from
                  a channel. Note that if the message doesn't exist, ``None``
                  will appear in its place, so that zipping the list of IDs
                  with the messages can match one-to-one.
  
                  .. note::
  
                      At the time of writing, Telegram will **not** return
                      :tl:`MessageEmpty` for :tl:`InputMessageReplyTo` IDs that
                      failed (i.e. the message is not replying to any, or is
                      replying to a deleted message). This means that it is
                      **not** possible to match messages one-by-one, so be
                      careful if you use non-integers in this parameter.
  
              reverse (`bool`, optional):
                  If set to ``True``, the messages will be returned in reverse
                  order (from oldest to newest, instead of the default newest
                  to oldest). This also means that the meaning of `offset_id`
                  and `offset_date` parameters is reversed, although they will
                  still be exclusive. `min_id` becomes equivalent to `offset_id`
                  instead of being `max_id` as well since messages are returned
                  in ascending order.
  
                  You cannot use this if both `entity` and `ids` are ``None``.
  
          Yields:
              Instances of `telethon.tl.custom.message.Message`.
  
          Notes:
              Telegram's flood wait limit for :tl:`GetHistoryRequest` seems to
              be around 30 seconds per 10 requests, therefore a sleep of 1
              second is the default for this limit (or above).
          """
  
          if ids is not None:
              return _IDsIter(self, limit, entity=entity, ids=ids)
  
          return _MessagesIter(
              client=self,
              reverse=reverse,
              wait_time=wait_time,
              limit=limit,
              entity=entity,
              offset_id=offset_id,
              min_id=min_id,
              max_id=max_id,
              from_user=from_user,
              offset_date=offset_date,
              add_offset=add_offset,
              filter=filter,
              search=search
          )