telegrinder 0.3.4.post1__py3-none-any.whl → 0.4.1__py3-none-any.whl

telegrinder/bot/cute_types/message.py

@@ -6,15 +6,11 @@ import fntypes.option
 from fntypes.co import Result, Some, Variative
 
 from telegrinder.api.api import API, APIError
-from telegrinder.bot.cute_types.base import BaseCute, compose_method_params, shortcut
-from telegrinder.bot.cute_types.utils import (
-    compose_link_preview_options,
-    compose_reactions,
-    compose_reply_params,
-    input_media,
-)
-from telegrinder.model import From, field, get_params
-from telegrinder.msgspec_utils import Nothing, Option
+from telegrinder.bot.cute_types.base import BaseCute, compose_method_params
+from telegrinder.bot.cute_types.utils import compose_reactions, input_media
+from telegrinder.model import UNSET, From, field, get_params
+from telegrinder.msgspec_utils import Option
+from telegrinder.tools.magic import shortcut
 from telegrinder.types import *
 
 if typing.TYPE_CHECKING:
@@ -22,15 +18,15 @@ if typing.TYPE_CHECKING:
 
     from telegrinder.bot.cute_types.callback_query import CallbackQueryCute
 
-MediaType: typing.TypeAlias = typing.Literal[
+type MediaType = typing.Literal[
     "animation",
     "audio",
     "document",
     "photo",
     "video",
 ]
-InputMediaType: typing.TypeAlias = InputMedia | tuple[MediaType, InputFile | str]
-ReplyMarkup: typing.TypeAlias = InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply
+type InputMediaType = str | InputMedia | InputFile
+type ReplyMarkup = InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply
 
 
 async def execute_method_answer(
@@ -44,17 +40,6 @@ async def execute_method_answer(
         default_params={"chat_id", "message_thread_id"},
         validators={"message_thread_id": lambda x: x.is_topic_message.unwrap_or(False)},
     )
-    reply_parameters = params.get("reply_parameters")
-    link_preview_options = params.get("link_preview_options")
-
-    if reply_parameters is not None and isinstance(reply_parameters, dict):
-        reply_parameters.setdefault("message_id", params.get("message_id", message.message_id))
-        reply_parameters.setdefault("chat_id", params.get("chat_id"))
-        params["reply_parameters"] = compose_reply_params(**reply_parameters)
-
-    if link_preview_options is not None and isinstance(link_preview_options, dict):
-        params["link_preview_options"] = compose_link_preview_options(**link_preview_options)
-
     result = await getattr(message.ctx_api, method_name)(**params)
     return result.map(
         lambda x: (
@@ -74,7 +59,13 @@ async def execute_method_reply(
     method_name: str,
     params: dict[str, typing.Any],
 ) -> Result[typing.Any, APIError]:
-    params.setdefault("reply_parameters", {})
+    params.setdefault(
+        "reply_parameters",
+        ReplyParameters(
+            params.get("message_id", message.message_id),
+            params.get("chat_id", message.chat_id),
+        ),
+    )
     return await execute_method_answer(message, method_name, params)
 
 
@@ -120,23 +111,25 @@ async def execute_method_edit(
 
 def get_entity_value(
     entity_value: typing.Literal["user", "url", "custom_emoji_id", "language"],
-    entities: fntypes.option.Option[list[MessageEntity]] = Nothing,
-    caption_entities: fntypes.option.Option[list[MessageEntity]] = Nothing,
+    entities: fntypes.option.Option[list[MessageEntity]],
+    caption_entities: fntypes.option.Option[list[MessageEntity]],
 ) -> fntypes.option.Option[typing.Any]:
     ents = entities.unwrap_or(caption_entities.unwrap_or_none())
     if not ents:
-        return Nothing
+        return fntypes.option.Nothing()
+
     for entity in ents:
-        if (obj := getattr(entity, entity_value, Nothing)) is not Nothing:
+        if (obj := getattr(entity, entity_value, fntypes.option.Nothing())) is not fntypes.option.Nothing():
             return obj if isinstance(obj, Some) else Some(obj)
-    return Nothing
+
+    return fntypes.option.Nothing()
 
 
 class MessageCute(BaseCute[Message], Message, kw_only=True):
     api: API
 
     reply_to_message: Option[MessageCute] = field(
-        default=Nothing,
+        default=UNSET,
         converter=From["MessageCute | None"],
     )
     """Optional. For replies in the same chat and message thread, the original
@@ -144,7 +137,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     reply_to_message fields even if it itself is a reply."""
 
     pinned_message: Option[Variative[MessageCute, InaccessibleMessage]] = field(
-        default=Nothing,
+        default=UNSET,
         converter=From["MessageCute | InaccessibleMessage | None"],
     )
     """Optional. Specified message was pinned. Note that the Message object in
@@ -154,50 +147,44 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     @property
     def mentioned_user(self) -> fntypes.option.Option[User]:
         """Mentioned user without username."""
-
         return get_entity_value("user", self.entities, self.caption_entities)
 
     @property
     def url(self) -> fntypes.option.Option[str]:
         """Clickable text URL."""
-
         return get_entity_value("url", self.entities, self.caption_entities)
 
     @property
     def programming_language(self) -> fntypes.option.Option[str]:
         """The programming language of the entity text."""
-
         return get_entity_value("language", self.entities, self.caption_entities)
 
     @property
     def custom_emoji_id(self) -> fntypes.option.Option[str]:
         """Unique identifier of the custom emoji."""
-
         return get_entity_value("custom_emoji_id", self.entities, self.caption_entities)
 
     @shortcut(
         "send_message",
         executor=execute_method_answer,
-        custom_params={"link_preview_options", "reply_parameters", "message_thread_id", "chat_id", "text"},
+        custom_params={"link_preview_options", "message_thread_id", "chat_id", "text"},
     )
     async def answer(
         self,
         text: str | None = None,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
+        entities: list[MessageEntity] | None = None,
+        link_preview_options: LinkPreviewOptions | None = None,
         message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         parse_mode: str | None = None,
-        entities: list[MessageEntity] | None = None,
-        disable_notification: bool | None = None,
         protect_content: bool | None = None,
-        link_preview_options: LinkPreviewOptions | dict[str, typing.Any] | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_message()`, see the [documentation](https://core.telegram.org/bots/api#sendmessage)
@@ -219,38 +206,37 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_message",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id", "message_id"},
+        custom_params={"message_thread_id", "chat_id", "message_id"},
     )
     async def reply(
         self,
         text: str,
+        *,
+        allow_paid_broadcast: bool | None = None,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
+        entities: list[MessageEntity] | None = None,
+        link_preview_options: LinkPreviewOptions | None = None,
+        message_effect_id: str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
-        business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         parse_mode: str | None = None,
-        entities: list[MessageEntity] | None = None,
-        disable_notification: bool | None = None,
         protect_content: bool | None = None,
-        link_preview_options: LinkPreviewOptions | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_message()`, see the [documentation](https://core.telegram.org/bots/api#sendmessage)
@@ -272,17 +258,19 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut("delete_message", custom_params={"message_thread_id", "chat_id", "message_id"})
     async def delete(
         self,
+        *,
         chat_id: int | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
@@ -301,7 +289,6 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         of a group, it can delete any message there. - If the bot has can_delete_messages
         permission in a supergroup or a channel, it can delete any message there.
         Returns True on success."""
-
         params = compose_method_params(
             params=get_params(locals()),
             update=self,
@@ -318,15 +305,16 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     async def edit(
         self,
         text: str,
+        *,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
+        entities: list[MessageEntity] | None = None,
+        inline_message_id: str | None = None,
+        link_preview_options: LinkPreviewOptions | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
         parse_mode: str | None = None,
-        entities: list[MessageEntity] | None = None,
-        link_preview_options: LinkPreviewOptions | dict[str, typing.Any] | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
-        inline_message_id: str | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
         """Shortcut `API.edit_message_text()`, see the [documentation](https://core.telegram.org/bots/api#editmessagetext)
@@ -352,31 +340,29 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param link_preview_options: Link preview generation options for the message.
 
         :param reply_markup: A JSON-serialized object for an inline keyboard."""
-
         ...
 
     @shortcut(
         "copy_message",
-        custom_params={"reply_parameters", "message_thread_id", "chat_id", "message_id", "from_chat_id"},
+        custom_params={"message_thread_id", "chat_id", "message_id", "from_chat_id"},
     )
     async def copy(
         self,
         chat_id: int | str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
+        caption: str | None = None,
+        caption_entities: list[MessageEntity] | None = None,
+        disable_notification: bool | None = None,
         from_chat_id: int | str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
-        caption: str | None = None,
         parse_mode: str | None = None,
-        caption_entities: list[MessageEntity] | None = None,
-        disable_notification: bool | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         show_caption_above_media: bool | None = None,
+        video_start_timestamp: int | None = None,
         **other: typing.Any,
     ) -> Result[MessageId, APIError]:
         """Shortcut `API.copy_message()`, see the [documentation](https://core.telegram.org/bots/api#copymessage)
@@ -387,7 +373,6 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         field correct_option_id is known to the bot. The method is analogous to
         the method forwardMessage, but the copied message doesn't have a link to
         the original message. Returns the MessageId of the sent message on success."""
-
         params = compose_method_params(
             params=get_params(locals()),
             update=self,
@@ -402,7 +387,7 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         if isinstance(reply_parameters, dict):
             reply_parameters.setdefault("message_id", params.get("message_id"))
             reply_parameters.setdefault("chat_id", params.get("chat_id"))
-            params["reply_parameters"] = compose_reply_params(**reply_parameters)
+            params["reply_parameters"] = ReplyParameters(**reply_parameters)
         return await self.ctx_api.copy_message(**params)
 
     @shortcut(
@@ -411,22 +396,20 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     )
     async def react(
         self,
-        reaction: (
-            str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType] | None
-        ) = None,
+        reaction: (str | ReactionEmoji | ReactionType | list[str | ReactionEmoji | ReactionType] | None) = None,
+        *,
         chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
-        message_id: int | None = None,
         is_big: bool | None = None,
+        message_id: int | None = None,
+        message_thread_id: int | None = None,
         **other: typing.Any,
     ) -> Result[bool, APIError]:
         """Shortcut `API.set_message_reaction()`, see the [documentation](https://core.telegram.org/bots/api#setmessagereaction)
 
         Use this method to change the chosen reactions on a message. Service messages
-        can't be reacted to. Automatically forwarded messages from a channel to
-        its discussion group have the same available reactions as messages in the
-        channel. Bots can't use paid reactions. Returns True on success."""
-
+        of some types can't be reacted to. Automatically forwarded messages from
+        a channel to its discussion group have the same available reactions as messages
+        in the channel. Bots can't use paid reactions. Returns True on success."""
         params = compose_method_params(
             params=get_params(locals()),
             update=self,
@@ -443,11 +426,13 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     async def forward(
         self,
         chat_id: int | str,
-        message_id: int | None = None,
+        *,
+        disable_notification: bool | None = None,
         from_chat_id: int | str | None = None,
+        message_id: int | None = None,
         message_thread_id: int | None = None,
-        disable_notification: bool | None = None,
         protect_content: bool | None = None,
+        video_start_timestamp: int | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.forward_message()`, see the [documentation](https://core.telegram.org/bots/api#forwardmessage)
@@ -461,10 +446,11 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
 
         :param from_chat_id: Unique identifier for the chat where the original message was sent (or channelusername in the format @channelusername).
 
+        :param video_start_timestamp: New start timestamp for the forwarded video in the message.
+
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the forwarded message from forwarding and saving.
         :param message_id: Message identifier in the chat specified in from_chat_id."""
-
         params = compose_method_params(
             params=get_params(locals()),
             update=self,
@@ -482,11 +468,12 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     @shortcut("pin_chat_message", custom_params={"message_thread_id", "chat_id", "message_id"})
     async def pin(
         self,
+        *,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
-        disable_notification: bool | None = None,
-        business_connection_id: str | None = None,
         **other: typing.Any,
     ) -> Result[bool, "APIError"]:
         """Shortcut `API.pin_chat_message()`, see the [documentation](https://core.telegram.org/bots/api#pinchatmessage)
@@ -503,7 +490,6 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param message_id: Identifier of a message to pin.
 
         :param disable_notification: Pass True if it is not necessary to send a notification to all chat membersabout the new pinned message. Notifications are always disabled in channelsand private chats."""
-
         params = compose_method_params(
             params=get_params(locals()),
             update=self,
@@ -515,10 +501,11 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     @shortcut("unpin_chat_message", custom_params={"message_thread_id", "chat_id", "message_id"})
     async def unpin(
         self,
+        *,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
-        business_connection_id: str | None = None,
         **other: typing.Any,
     ) -> Result[bool, "APIError"]:
         """Shortcut `API.unpin_chat_message()`, see the [documentation](https://core.telegram.org/bots/api#unpinchatmessage)
@@ -533,7 +520,6 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param chat_id: Unique identifier for the target chat or username of the target channel(in the format @channelusername).
 
         :param message_id: Identifier of the message to unpin. Required if business_connection_idis specified. If not specified, the most recent pinned message (by sendingdate) will be unpinned."""
-
         params = compose_method_params(
             params=get_params(locals()),
             update=self,
@@ -545,30 +531,28 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     @shortcut(
         "send_audio",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_audio(
         self,
         audio: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         duration: int | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         performer: str | None = None,
-        title: str | None = None,
-        thumbnail: InputFile | str | None = None,
-        disable_notification: bool | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        thumbnail: InputFile | str | None = None,
+        title: str | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_audio()`, see the [documentation](https://core.telegram.org/bots/api#sendaudio)
@@ -601,43 +585,42 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_animation",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_animation(
         self,
         animation: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
-        show_caption_above_media: bool | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         duration: int | None = None,
-        width: int | None = None,
-        height: int | None = None,
-        thumbnail: InputFile | str | None = None,
         has_spoiler: bool | None = None,
-        disable_notification: bool | None = None,
+        height: int | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        show_caption_above_media: bool | None = None,
+        thumbnail: InputFile | str | None = None,
+        width: int | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_animation()`, see the [documentation](https://core.telegram.org/bots/api#sendanimation)
@@ -671,40 +654,39 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_document",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_document(
         self,
         document: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
+        chat_id: int | str | None = None,
         disable_content_type_detection: bool | None = None,
-        show_caption_above_media: bool | None = None,
-        thumbnail: InputFile | str | None = None,
         disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        show_caption_above_media: bool | None = None,
+        thumbnail: InputFile | str | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_document()`, see the [documentation](https://core.telegram.org/bots/api#senddocument)
@@ -731,39 +713,38 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_photo",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_photo(
         self,
         photo: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
-        show_caption_above_media: bool | None = None,
-        has_spoiler: bool | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        has_spoiler: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        show_caption_above_media: bool | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_photo()`, see the [documentation](https://core.telegram.org/bots/api#sendphoto)
@@ -789,35 +770,34 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_sticker",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_sticker(
         self,
         sticker: InputFile | str,
+        *,
+        allow_paid_broadcast: bool | None = None,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         emoji: str | None = None,
-        message_thread_id: int | None = None,
         message_effect_id: str | None = None,
-        business_connection_id: str | None = None,
-        disable_notification: bool | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_sticker()`, see the [documentation](https://core.telegram.org/bots/api#sendsticker)
@@ -837,44 +817,45 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_video",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_video(
         self,
         video: InputFile | str,
-        chat_id: int | str | None = None,
-        emoji: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
+        caption: str | None = None,
+        caption_entities: list[MessageEntity] | None = None,
+        chat_id: int | str | None = None,
+        cover: InputFile | str | None = None,
         disable_notification: bool | None = None,
-        protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
         duration: int | None = None,
-        width: int | None = None,
+        emoji: str | None = None,
+        has_spoiler: bool | None = None,
         height: int | None = None,
-        thumbnail: InputFile | str | None = None,
-        caption: str | None = None,
-        caption_entities: list[MessageEntity] | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        protect_content: bool | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         show_caption_above_media: bool | None = None,
-        has_spoiler: bool | None = None,
+        start_timestamp: int | None = None,
         supports_streaming: bool | None = None,
+        thumbnail: InputFile | str | None = None,
+        width: int | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_video()`, see the [documentation](https://core.telegram.org/bots/api#sendvideo)
@@ -897,6 +878,9 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param height: Video height.
 
         :param thumbnail: Thumbnail of the file sent; can be ignored if thumbnail generation for thefile is supported server-side. The thumbnail should be in JPEG format andless than 200 kB in size. A thumbnail's width and height should not exceed320. Ignored if the file is not uploaded using multipart/form-data. Thumbnailscan't be reused and can be only uploaded as a new file, so you can pass `attach://<file_attach_name>`if the thumbnail was uploaded using multipart/form-data under <file_attach_name>.More information on Sending Files: https://core.telegram.org/bots/api#sending-files.
+        :param cover: Cover for the video in the message. Pass a file_id to send a file that existson the Telegram servers (recommended), pass an HTTP URL for Telegram toget a file from the Internet, or pass `attach://<file_attach_name>` toupload a new one using multipart/form-data under <file_attach_name>name. More information on Sending Files: https://core.telegram.org/bots/api#sending-files.
+        :param start_timestamp: Start timestamp for the video in the message.
+
         :param caption: Video caption (may also be used when resending videos by file_id), 0-1024characters after entities parsing.
 
         :param parse_mode: Mode for parsing entities in the video caption. See formatting optionsfor more details.
@@ -912,37 +896,36 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_video_note",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_video_note(
         self,
         video_note: InputFile | str,
-        chat_id: int | str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         duration: int | None = None,
         length: int | None = None,
+        message_effect_id: str | None = None,
         message_thread_id: int | None = None,
-        thumbnail: InputFile | str | None = None,
-        disable_notification: bool | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        thumbnail: InputFile | str | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_video_note()`, see the [documentation](https://core.telegram.org/bots/api#sendvideonote)
@@ -966,38 +949,37 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_voice",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_voice(
         self,
         voice: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
-        duration: int | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        duration: int | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_voice()`, see the [documentation](https://core.telegram.org/bots/api#sendvoice)
@@ -1026,48 +1008,47 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_poll",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_poll(
         self,
         question: str,
+        *,
         options: list[InputPollOption],
-        chat_id: int | str | None = None,
-        business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
-        question_parse_mode: str | None = None,
-        question_entities: list[MessageEntity] | None = None,
-        is_anonymous: bool | None = None,
-        type: typing.Literal["quiz", "regular"] | None = None,
+        allow_paid_broadcast: bool | None = None,
         allows_multiple_answers: bool | None = None,
-        show_caption_above_media: bool | None = None,
+        business_connection_id: str | None = None,
+        chat_id: int | str | None = None,
+        close_date: datetime | int | None = None,
         correct_option_id: int | None = None,
+        disable_notification: bool | None = None,
         explanation: str | None = None,
-        explanation_parse_mode: str | None = None,
         explanation_entities: list[MessageEntity] | None = None,
-        open_period: int | None = None,
-        close_date: datetime | int | None = None,
+        explanation_parse_mode: str | None = None,
+        is_anonymous: bool | None = None,
         is_closed: bool | None = None,
-        disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        open_period: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        question_entities: list[MessageEntity] | None = None,
+        question_parse_mode: str | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        show_caption_above_media: bool | None = None,
+        type: typing.Literal["quiz", "regular"] | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_poll()`, see the [documentation](https://core.telegram.org/bots/api#sendpoll)
@@ -1110,41 +1091,40 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_venue",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_venue(
         self,
+        *,
+        address: str,
         latitude: float,
         longitude: float,
         title: str,
-        address: str,
-        chat_id: int | str | None = None,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         foursquare_id: str | None = None,
         foursquare_type: str | None = None,
         google_place_id: str | None = None,
         google_place_type: str | None = None,
-        disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_venue()`, see the [documentation](https://core.telegram.org/bots/api#sendvenue)
@@ -1176,34 +1156,33 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_dice",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_dice(
         self,
         emoji: DiceEmoji | None = None,
-        chat_id: int | str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_dice()`, see the [documentation](https://core.telegram.org/bots/api#senddice)
@@ -1220,30 +1199,33 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_game",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_game(
         self,
         game_short_name: str,
-        chat_id: int | str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_game()`, see the [documentation](https://core.telegram.org/bots/api#sendgame)
@@ -1260,68 +1242,71 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: A JSON-serialized object for an inline keyboard. If empty, one 'Play game_title'button will be shown. If not empty, the first button must launch the game."""
-
         ...
 
     @shortcut(
         "send_invoice",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_invoice(
         self,
-        title: str,
+        *,
+        currency: Currency,
         description: str,
         payload: str,
-        currency: str,
         prices: list[LabeledPrice],
-        chat_id: int | str | None = None,
+        title: str,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        provider_token: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
+        is_flexible: bool | None = None,
         max_tip_amount: int | None = None,
-        suggested_tip_amounts: list[int] | None = None,
-        start_parameter: str | None = None,
-        provider_data: str | None = None,
-        photo_url: str | None = None,
-        photo_size: int | None = None,
-        photo_width: int | None = None,
-        photo_height: int | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        need_email: bool | None = None,
         need_name: bool | None = None,
         need_phone_number: bool | None = None,
-        need_email: bool | None = None,
         need_shipping_address: bool | None = None,
-        send_phone_number_to_provider: bool | None = None,
-        send_email_to_provider: bool | None = None,
-        is_flexible: bool | None = None,
-        disable_notification: bool | None = None,
+        photo_height: int | None = None,
+        photo_size: int | None = None,
+        photo_url: str | None = None,
+        photo_width: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
+        provider_data: str | None = None,
+        provider_token: str | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        send_email_to_provider: bool | None = None,
+        send_phone_number_to_provider: bool | None = None,
+        start_parameter: str | None = None,
+        suggested_tip_amounts: list[int] | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_invoice()`, see the [documentation](https://core.telegram.org/bots/api#sendinvoice)
 
         Use this method to send invoices. On success, the sent Message is returned."""
-
         ...
 
     @shortcut(
         "send_chat_action",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_chat_action(
         self,
         action: ChatAction,
-        chat_id: int | str | None = None,
+        *,
         business_connection_id: str | None = None,
+        chat_id: int | str | None = None,
         message_thread_id: int | None = None,
         **other: typing.Any,
     ) -> Result[bool, APIError]:
@@ -1338,26 +1323,25 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
 
         :param message_thread_id: Unique identifier for the target message thread; for supergroups only.
         :param action: Type of action to broadcast. Choose one, depending on what the user is aboutto receive: typing for text messages, upload_photo for photos, record_videoor upload_video for videos, record_voice or upload_voice for voice notes,upload_document for general files, choose_sticker for stickers, find_locationfor location data, record_video_note or upload_video_note for videonotes."""
-
         ...
 
     @shortcut(
         "send_media_group",
-        custom_params={"media", "reply_parameters", "message_thread_id"},
+        custom_params={"media", "chat_id", "message_thread_id"},
     )
     async def answer_media_group(
         self,
-        media: InputMediaType | list[InputMediaType],
-        chat_id: int | str,
+        media: InputMedia | list[InputMedia],
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
-        caption: str | list[str] | None = None,
-        parse_mode: str | list[str] | None = None,
-        caption_entities: list[MessageEntity] | list[list[MessageEntity]] | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        media_type: MediaType | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[list[MessageCute], APIError]:
         """Shortcut `API.send_media_group()`, see the [documentation](https://core.telegram.org/bots/api#sendmediagroup)
@@ -1375,58 +1359,38 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
 
         :param disable_notification: Sends messages silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent messages from forwarding and saving.
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to."""
-
         media = [media] if not isinstance(media, list) else media
         params = get_params(locals())
-        caption_entities_lst = typing.cast(
-            list[list[MessageEntity]],
-            [caption_entities]
-            if caption_entities and len(caption_entities) == 1 and not isinstance(caption_entities[0], list)
-            else caption_entities,
-        )
-
-        for i, m in enumerate(media[:]):
-            if isinstance(m, tuple):
-                media.insert(
-                    i,
-                    input_media(  # type: ignore
-                        *media.pop(i),  # type: ignore
-                        caption=caption if not isinstance(caption, list) else caption[i],
-                        caption_entities=caption_entities_lst[i] if caption_entities_lst else None,
-                        parse_mode=parse_mode if not isinstance(parse_mode, list) else parse_mode[i],
-                    ),
-                )
-
         return await execute_method_answer(self, "send_media_group", params)
 
     @shortcut(
         "send_location",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_location(
         self,
+        *,
         latitude: float,
         longitude: float,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
-        horizontal_accuracy: float | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         heading: int | None = None,
+        horizontal_accuracy: float | None = None,
         live_period: int | None = None,
-        proximity_alert_radius: int | None = None,
-        disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        proximity_alert_radius: int | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_location()`, see the [documentation](https://core.telegram.org/bots/api#sendlocation)
@@ -1451,37 +1415,36 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_contact",
         executor=execute_method_answer,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def answer_contact(
         self,
-        phone_number: str,
+        *,
         first_name: str,
-        last_name: str | None = None,
-        vcard: str | None = None,
-        chat_id: int | str | None = None,
+        phone_number: str,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        last_name: str | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        vcard: str | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_contact()`, see the [documentation](https://core.telegram.org/bots/api#sendcontact)
@@ -1504,41 +1467,40 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_audio",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_audio(
         self,
         audio: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         duration: int | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         performer: str | None = None,
-        title: str | None = None,
-        thumbnail: InputFile | str | None = None,
-        disable_notification: bool | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        thumbnail: InputFile | str | None = None,
+        title: str | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_audio()`, see the [documentation](https://core.telegram.org/bots/api#sendaudio)
@@ -1571,43 +1533,42 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_animation",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_animation(
         self,
         animation: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
-        show_caption_above_media: bool | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         duration: int | None = None,
-        width: int | None = None,
-        height: int | None = None,
-        thumbnail: InputFile | str | None = None,
         has_spoiler: bool | None = None,
-        disable_notification: bool | None = None,
+        height: int | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        show_caption_above_media: bool | None = None,
+        thumbnail: InputFile | str | None = None,
+        width: int | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_animation()`, see the [documentation](https://core.telegram.org/bots/api#sendanimation)
@@ -1641,40 +1602,39 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_document",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_document(
         self,
         document: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
+        chat_id: int | str | None = None,
         disable_content_type_detection: bool | None = None,
-        show_caption_above_media: bool | None = None,
-        thumbnail: InputFile | str | None = None,
         disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        show_caption_above_media: bool | None = None,
+        thumbnail: InputFile | str | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_document()`, see the [documentation](https://core.telegram.org/bots/api#senddocument)
@@ -1701,39 +1661,38 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_photo",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_photo(
         self,
         photo: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
-        show_caption_above_media: bool | None = None,
-        has_spoiler: bool | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        has_spoiler: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        show_caption_above_media: bool | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_photo()`, see the [documentation](https://core.telegram.org/bots/api#sendphoto)
@@ -1759,35 +1718,34 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_sticker",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_sticker(
         self,
         sticker: InputFile | str,
+        *,
+        allow_paid_broadcast: bool | None = None,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         emoji: str | None = None,
-        message_thread_id: int | None = None,
         message_effect_id: str | None = None,
-        business_connection_id: str | None = None,
-        disable_notification: bool | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_sticker()`, see the [documentation](https://core.telegram.org/bots/api#sendsticker)
@@ -1807,45 +1765,45 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_video",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_video(
         self,
-        sticker: InputFile | str,
         video: InputFile | str,
-        chat_id: int | str | None = None,
-        emoji: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
+        caption: str | None = None,
+        caption_entities: list[MessageEntity] | None = None,
+        chat_id: int | str | None = None,
+        cover: InputFile | str | None = None,
         disable_notification: bool | None = None,
-        protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
         duration: int | None = None,
-        width: int | None = None,
+        emoji: str | None = None,
+        has_spoiler: bool | None = None,
         height: int | None = None,
-        thumbnail: InputFile | str | None = None,
-        caption: str | None = None,
-        caption_entities: list[MessageEntity] | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        protect_content: bool | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         show_caption_above_media: bool | None = None,
-        has_spoiler: bool | None = None,
+        start_timestamp: int | None = None,
         supports_streaming: bool | None = None,
+        thumbnail: InputFile | str | None = None,
+        width: int | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_video()`, see the [documentation](https://core.telegram.org/bots/api#sendvideo)
@@ -1868,6 +1826,9 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param height: Video height.
 
         :param thumbnail: Thumbnail of the file sent; can be ignored if thumbnail generation for thefile is supported server-side. The thumbnail should be in JPEG format andless than 200 kB in size. A thumbnail's width and height should not exceed320. Ignored if the file is not uploaded using multipart/form-data. Thumbnailscan't be reused and can be only uploaded as a new file, so you can pass `attach://<file_attach_name>`if the thumbnail was uploaded using multipart/form-data under <file_attach_name>.More information on Sending Files: https://core.telegram.org/bots/api#sending-files.
+        :param cover: Cover for the video in the message. Pass a file_id to send a file that existson the Telegram servers (recommended), pass an HTTP URL for Telegram toget a file from the Internet, or pass `attach://<file_attach_name>` toupload a new one using multipart/form-data under <file_attach_name>name. More information on Sending Files: https://core.telegram.org/bots/api#sending-files.
+        :param start_timestamp: Start timestamp for the video in the message.
+
         :param caption: Video caption (may also be used when resending videos by file_id), 0-1024characters after entities parsing.
 
         :param parse_mode: Mode for parsing entities in the video caption. See formatting optionsfor more details.
@@ -1883,37 +1844,36 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_video_note",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_video_note(
         self,
         video_note: InputFile | str,
-        chat_id: int | str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         duration: int | None = None,
         length: int | None = None,
+        message_effect_id: str | None = None,
         message_thread_id: int | None = None,
-        thumbnail: InputFile | str | None = None,
-        disable_notification: bool | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        thumbnail: InputFile | str | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_video_note()`, see the [documentation](https://core.telegram.org/bots/api#sendvideonote)
@@ -1937,38 +1897,37 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_voice",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_voice(
         self,
         voice: InputFile | str,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
-        duration: int | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        duration: int | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_voice()`, see the [documentation](https://core.telegram.org/bots/api#sendvoice)
@@ -1997,48 +1956,47 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_poll",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_poll(
         self,
         question: str,
+        *,
         options: list[InputPollOption],
-        chat_id: int | str | None = None,
-        business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
-        question_parse_mode: str | None = None,
-        question_entities: list[MessageEntity] | None = None,
-        is_anonymous: bool | None = None,
-        type: typing.Literal["quiz", "regular"] | None = None,
+        allow_paid_broadcast: bool | None = None,
         allows_multiple_answers: bool | None = None,
-        show_caption_above_media: bool | None = None,
+        business_connection_id: str | None = None,
+        chat_id: int | str | None = None,
+        close_date: datetime | int | None = None,
         correct_option_id: int | None = None,
+        disable_notification: bool | None = None,
         explanation: str | None = None,
-        explanation_parse_mode: str | None = None,
         explanation_entities: list[MessageEntity] | None = None,
-        open_period: int | None = None,
-        close_date: datetime | int | None = None,
+        explanation_parse_mode: str | None = None,
+        is_anonymous: bool | None = None,
         is_closed: bool | None = None,
-        disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        open_period: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        question_entities: list[MessageEntity] | None = None,
+        question_parse_mode: str | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        show_caption_above_media: bool | None = None,
+        type: typing.Literal["quiz", "regular"] | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_poll()`, see the [documentation](https://core.telegram.org/bots/api#sendpoll)
@@ -2081,41 +2039,40 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_venue",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_venue(
         self,
+        *,
+        address: str,
         latitude: float,
         longitude: float,
         title: str,
-        address: str,
-        chat_id: int | str | None = None,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         foursquare_id: str | None = None,
         foursquare_type: str | None = None,
         google_place_id: str | None = None,
         google_place_type: str | None = None,
-        disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_venue()`, see the [documentation](https://core.telegram.org/bots/api#sendvenue)
@@ -2147,34 +2104,33 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_dice",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_dice(
         self,
         emoji: DiceEmoji | None = None,
-        chat_id: int | str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_dice()`, see the [documentation](https://core.telegram.org/bots/api#senddice)
@@ -2191,30 +2147,33 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_game",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_game(
         self,
         game_short_name: str,
-        chat_id: int | str | None = None,
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_game()`, see the [documentation](https://core.telegram.org/bots/api#sendgame)
@@ -2231,83 +2190,80 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: A JSON-serialized object for an inline keyboard. If empty, one 'Play game_title'button will be shown. If not empty, the first button must launch the game."""
-
         ...
 
     @shortcut(
         "send_invoice",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_invoice(
         self,
-        title: str,
+        *,
+        currency: Currency,
         description: str,
         payload: str,
-        currency: str,
         prices: list[LabeledPrice],
-        chat_id: int | str | None = None,
+        title: str,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        provider_token: str | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
+        is_flexible: bool | None = None,
         max_tip_amount: int | None = None,
-        suggested_tip_amounts: list[int] | None = None,
-        start_parameter: str | None = None,
-        provider_data: str | None = None,
-        photo_url: str | None = None,
-        photo_size: int | None = None,
-        photo_width: int | None = None,
-        photo_height: int | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
+        need_email: bool | None = None,
         need_name: bool | None = None,
         need_phone_number: bool | None = None,
-        need_email: bool | None = None,
         need_shipping_address: bool | None = None,
-        send_phone_number_to_provider: bool | None = None,
-        send_email_to_provider: bool | None = None,
-        is_flexible: bool | None = None,
-        disable_notification: bool | None = None,
+        photo_height: int | None = None,
+        photo_size: int | None = None,
+        photo_url: str | None = None,
+        photo_width: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
+        provider_data: str | None = None,
+        provider_token: str | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        send_email_to_provider: bool | None = None,
+        send_phone_number_to_provider: bool | None = None,
+        start_parameter: str | None = None,
+        suggested_tip_amounts: list[int] | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_invoice()`, see the [documentation](https://core.telegram.org/bots/api#sendinvoice)
 
         Use this method to send invoices. On success, the sent Message is returned."""
-
         ...
 
     @shortcut(
         "send_media_group",
         custom_params={
             "media",
-            "reply_parameters",
             "chat_id",
             "message_thread_id",
-            "caption",
-            "caption_entities",
-            "parse_mode",
         },
     )
     async def reply_media_group(
         self,
-        media: InputMediaType | list[InputMediaType],
-        chat_id: int | str | None = None,
+        media: InputMedia | list[InputMedia],
+        *,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
-        caption: str | list[str] | None = None,
-        parse_mode: str | list[str] | None = None,
-        caption_entities: list[MessageEntity] | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[list[MessageCute], APIError]:
         """Shortcut `API.send_media_group()`, see the [documentation](https://core.telegram.org/bots/api#sendmediagroup)
@@ -2325,39 +2281,38 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
 
         :param disable_notification: Sends messages silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent messages from forwarding and saving.
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to."""
-
         params = get_params(locals())
-        params.setdefault("reply_parameters", {})
+        params.setdefault("reply_parameters", ReplyParameters(self.message_id))
         return await self.answer_media_group(**params)
 
     @shortcut(
         "send_location",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_location(
         self,
+        *,
         latitude: float,
         longitude: float,
-        chat_id: int | str | None = None,
-        message_thread_id: int | None = None,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_effect_id: str | None = None,
-        horizontal_accuracy: float | None = None,
+        chat_id: int | str | None = None,
+        disable_notification: bool | None = None,
         heading: int | None = None,
+        horizontal_accuracy: float | None = None,
         live_period: int | None = None,
-        proximity_alert_radius: int | None = None,
-        disable_notification: bool | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        proximity_alert_radius: int | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_location()`, see the [documentation](https://core.telegram.org/bots/api#sendlocation)
@@ -2382,37 +2337,36 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
         "send_contact",
         executor=execute_method_reply,
-        custom_params={"reply_parameters", "message_thread_id", "chat_id"},
+        custom_params={"message_thread_id", "chat_id"},
     )
     async def reply_contact(
         self,
-        phone_number: str,
+        *,
         first_name: str,
-        last_name: str | None = None,
-        vcard: str | None = None,
-        chat_id: int | str | None = None,
+        phone_number: str,
+        allow_paid_broadcast: bool | None = None,
         business_connection_id: str | None = None,
-        message_thread_id: int | None = None,
-        message_effect_id: str | None = None,
+        chat_id: int | str | None = None,
         disable_notification: bool | None = None,
+        last_name: str | None = None,
+        message_effect_id: str | None = None,
+        message_thread_id: int | None = None,
         protect_content: bool | None = None,
-        reply_parameters: ReplyParameters | dict[str, typing.Any] | None = None,
-        reply_markup: InlineKeyboardMarkup
-        | ReplyKeyboardMarkup
-        | ReplyKeyboardRemove
-        | ForceReply
-        | None = None,
+        reply_markup: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply | None = None,
+        reply_parameters: ReplyParameters | None = None,
+        vcard: str | None = None,
         **other: typing.Any,
     ) -> Result[MessageCute, APIError]:
         """Shortcut `API.send_contact()`, see the [documentation](https://core.telegram.org/bots/api#sendcontact)
@@ -2435,12 +2389,13 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param disable_notification: Sends the message silently. Users will receive a notification with no sound.
         :param protect_content: Protects the contents of the sent message from forwarding and saving.
 
+        :param allow_paid_broadcast: Pass True to allow up to 1000 messages per second, ignoring broadcastinglimits for a fee of 0.1 Telegram Stars per message. The relevant Stars willbe withdrawn from the bot's balance.
+
         :param message_effect_id: Unique identifier of the message effect to be added to the message; for privatechats only.
 
         :param reply_parameters: Description of the message to reply to.
 
         :param reply_markup: Additional interface options. A JSON-serialized object for an inlinekeyboard, custom reply keyboard, instructions to remove a reply keyboardor to force a reply from the user."""
-
         ...
 
     @shortcut(
@@ -2450,18 +2405,18 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     )
     async def edit_live_location(
         self,
-        latitude: float,
+        *,
         longitude: float,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
-        message_id: int | None = None,
-        message_thread_id: int | None = None,
+        heading: int | None = None,
+        horizontal_accuracy: float | None = None,
         inline_message_id: str | None = None,
         live_period: int | None = None,
-        horizontal_accuracy: float | None = None,
-        heading: int | None = None,
+        message_id: int | None = None,
+        message_thread_id: int | None = None,
         proximity_alert_radius: int | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
         """Shortcut `API.edit_message_live_location()`, see the [documentation](https://core.telegram.org/bots/api#editmessagelivelocation)
@@ -2489,7 +2444,6 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param proximity_alert_radius: The maximum distance for proximity alerts about approaching another chatmember, in meters. Must be between 1 and 100000 if specified.
 
         :param reply_markup: A JSON-serialized object for a new inline keyboard."""
-
         ...
 
     @shortcut(
@@ -2500,15 +2454,16 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     async def edit_caption(
         self,
         caption: str | None = None,
+        *,
+        business_connection_id: str | None = None,
+        caption_entities: list[MessageEntity] | None = None,
         chat_id: int | str | None = None,
+        inline_message_id: str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
         parse_mode: str | None = None,
-        caption_entities: list[MessageEntity] | None = None,
-        show_caption_above_media: bool | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
-        inline_message_id: str | None = None,
+        show_caption_above_media: bool | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
         """Shortcut `API.edit_message_caption()`, see the [documentation](https://core.telegram.org/bots/api#editmessagecaption)
@@ -2533,7 +2488,6 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param show_caption_above_media: Pass True, if the caption must be shown above the message media. Supportedonly for animation, photo and video messages.
 
         :param reply_markup: A JSON-serialized object for an inline keyboard."""
-
         ...
 
     @shortcut(
@@ -2552,29 +2506,30 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     async def edit_media(
         self,
         media: InputFile | InputMedia | str,
-        type: MediaType | None = None,
+        *,
+        business_connection_id: str | None = None,
         caption: str | None = None,
-        parse_mode: str | None = None,
         caption_entities: list[MessageEntity] | None = None,
         chat_id: int | str | None = None,
+        inline_message_id: str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
+        parse_mode: str | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
-        inline_message_id: str | None = None,
+        type: MediaType | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
         """Shortcut `API.edit_message_media()`, see the [documentation](https://core.telegram.org/bots/api#editmessagemedia)
 
-        Use this method to edit animation, audio, document, photo, or video messages.
-        If a message is part of a message album, then it can be edited only to an audio
-        for audio albums, only to a document for document albums and to a photo or
-        a video otherwise. When an inline message is edited, a new file can't be uploaded;
-        use a previously uploaded file via its file_id or specify a URL. On success,
-        if the edited message is not an inline message, the edited Message is returned,
-        otherwise True is returned. Note that business messages that were not sent
-        by the bot and do not contain an inline keyboard can only be edited within
-        48 hours from the time they were sent.
+        Use this method to edit animation, audio, document, photo, or video messages,
+        or to add media to text messages. If a message is part of a message album, then
+        it can be edited only to an audio for audio albums, only to a document for document
+        albums and to a photo or a video otherwise. When an inline message is edited,
+        a new file can't be uploaded; use a previously uploaded file via its file_id
+        or specify a URL. On success, if the edited message is not an inline message,
+        the edited Message is returned, otherwise True is returned. Note that business
+        messages that were not sent by the bot and do not contain an inline keyboard
+        can only be edited within 48 hours from the time they were sent.
         :param business_connection_id: Unique identifier of the business connection on behalf of which the messageto be edited was sent.
 
         :param chat_id: Required if inline_message_id is not specified. Unique identifier forthe target chat or username of the target channel (in the format @channelusername).
@@ -2585,11 +2540,9 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param media: A JSON-serialized object for a new media content of the message.
 
         :param reply_markup: A JSON-serialized object for a new inline keyboard."""
-
         params = get_params(locals())
-
         if not isinstance(media, InputMedia):
-            assert type, "parameter 'type' is required, because 'media' is not an 'InputMedia' object."
+            assert type, "Parameter 'type' is required, because 'media' is a file id or an 'InputFile' object."
             params["media"] = input_media(
                 params.pop("type"),
                 media,
@@ -2607,12 +2560,13 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
     )
     async def edit_reply_markup(
         self,
+        *,
+        business_connection_id: str | None = None,
         chat_id: int | str | None = None,
+        inline_message_id: str | None = None,
         message_id: int | None = None,
         message_thread_id: int | None = None,
         reply_markup: InlineKeyboardMarkup | None = None,
-        business_connection_id: str | None = None,
-        inline_message_id: str | None = None,
         **other: typing.Any,
     ) -> Result[Variative[MessageCute, bool], APIError]:
         """Shortcut `API.edit_message_reply_markup()`, see the [documentation](https://core.telegram.org/bots/api#editmessagereplymarkup)
@@ -2630,7 +2584,6 @@ class MessageCute(BaseCute[Message], Message, kw_only=True):
         :param inline_message_id: Required if chat_id and message_id are not specified. Identifier of theinline message.
 
         :param reply_markup: A JSON-serialized object for an inline keyboard."""
-
         ...