awg-gus-bot/vendor/gusvoice_bot/_generated.py

# Generated by `node scripts/gen-bot-api.mjs` from docs/bot-api/openapi.json — DO NOT EDIT.
# CI (`gen-bot-api.mjs --check`) fails when this file is out of date.
# SPDX-License-Identifier: MIT
"""Types and method wrappers of the GusVoice Bot API, generated from the OpenAPI document."""
from __future__ import annotations

from typing import Any, Dict, List, Literal, Optional, Sequence, TypedDict, Union

SCHEMA_VERSION = "1.4.0"
"""Version of the OpenAPI document this module was generated from."""
API_VERSION = 4
"""Bot API level (`getMe.api_version`) the wrappers below know about."""

METHODS: Dict[str, int] = {
    "getMe": 1,
    "getUpdates": 1,
    "setWebhook": 1,
    "deleteWebhook": 1,
    "getWebhookInfo": 1,
    "sendMessage": 1,
    "editMessageText": 1,
    "deleteMessage": 1,
    "sendChatAction": 1,
    "getChat": 1,
    "editMessageReplyMarkup": 2,
    "answerCallbackQuery": 2,
    "setMyCommands": 2,
    "getMyCommands": 2,
    "deleteMyCommands": 2,
    "setMessageReaction": 3,
    "pinChatMessage": 3,
    "unpinChatMessage": 3,
    "getChatHistory": 3,
    "getChatMember": 3,
    "getChatMemberCount": 3,
    "getChatMembers": 3,
    "getMyServers": 3,
    "getServer": 3,
    "addChatMemberRole": 3,
    "removeChatMemberRole": 3,
    "banChatMember": 3,
    "unbanChatMember": 3,
    "kickChatMember": 3,
    "leaveChat": 3,
    "joinVoice": 4,
    "leaveVoice": 4,
    "getVoiceChatMembers": 4,
}
"""Every Bot API method → the API level it appeared in (`getMe.api_version`)."""

UPDATE_TYPES = (
    "message",
    "edited_message",
    "message_deleted",
    "my_chat_member",
    "callback_query",
    "message_reaction",
    "chat_member",
    "voice_state",
)
"""Update kinds (one key besides `update_id` in every `Update`); unknown kinds may appear — ignore them."""


# required: url, file_name, mime_type, file_size
Attachment = TypedDict("Attachment", {
    "url": "str",
    "file_name": "str",
    "mime_type": "str",
    "file_size": "float",
}, total=False)

# required: command, description
BotCommand = TypedDict("BotCommand", {
    "command": "str",
    "description": "str",
}, total=False)

# Supported `type`: default, all_private_chats, all_group_chats; other types are rejected with 400.
# required: type
BotCommandScope = TypedDict("BotCommandScope", {
    "type": "str",
}, total=False)

# required: id, username, display_name, bot, description, about, public
BotUser = TypedDict("BotUser", {
    "id": "str",
    "username": "str",
    "display_name": "str",
    "bot": "bool",
    "instance_domain": "str",
    "description": "str",
    "about": "str",
    "public": "bool",
    "api_version": "float",
    "features": "List[str]",
    "dropped_update_count": "float",
}, total=False)

# required: id, from, message, data, date
CallbackQuery = TypedDict("CallbackQuery", {
    "id": "str",
    "from": "User",
    "message": "Message",
    "data": "str",
    "date": "float",
}, total=False)

# required: id, type
Chat = TypedDict("Chat", {
    "id": "str",
    "type": "Literal[\"dm\", \"channel\", \"server\", \"voice\"]",
    "server_id": "str",
    "title": "str",
}, total=False)

# required: id, type
ChatFullInfo = TypedDict("ChatFullInfo", {
    "id": "str",
    "type": "Literal[\"dm\", \"channel\", \"server\", \"voice\"]",
    "server_id": "str",
    "title": "str",
    "user": "User",
    "member_count": "float",
}, total=False)

# required: user, status, role_ids
ChatMember = TypedDict("ChatMember", {
    "user": "User",
    "status": "Literal[\"creator\", \"member\", \"left\", \"kicked\"]",
    "nickname": "str",
    "role_ids": "List[str]",
    "joined_date": "float",
}, total=False)

# required: chat, from, date, old_status, new_status
ChatMemberUpdated = TypedDict("ChatMemberUpdated", {
    "chat": "Chat",
    "from": "User",
    "date": "float",
    "old_status": "Literal[\"creator\", \"member\", \"left\", \"kicked\"]",
    "new_status": "Literal[\"creator\", \"member\", \"left\", \"kicked\"]",
}, total=False)

# required: members
ChatMembersPage = TypedDict("ChatMembersPage", {
    "members": "List[ChatMember]",
    "next_offset": "str",
}, total=False)

# required: ok, error_code, description
Error = TypedDict("Error", {
    "ok": "bool",
    "error_code": "float",
    "description": "str",
    "retry_after": "float",
}, total=False)

# Exactly one of `callback_data` (1–64 BYTES of UTF-8, not characters) and `url` (http(s) only, no credentials in the address).
# required: text
InlineKeyboardButton = TypedDict("InlineKeyboardButton", {
    "text": "str",
    "callback_data": "str",
    "url": "str",
}, total=False)

# At least one row, 1–8 buttons in a row, at most 100 buttons in total.
# required: inline_keyboard
InlineKeyboardMarkup = TypedDict("InlineKeyboardMarkup", {
    "inline_keyboard": "List[List[InlineKeyboardButton]]",
}, total=False)

# required: —
InputEmbed = TypedDict("InputEmbed", {
    "title": "Optional[str]",
    "description": "Optional[str]",
    "url": "Optional[str]",
    "color": "Optional[int]",
    "timestamp": "Optional[str]",
    "fields": "Optional[List[Dict[str, Any]]]",
    "author": "Optional[Dict[str, Any]]",
    "footer": "Optional[Dict[str, Any]]",
    "image": "Optional[Dict[str, Any]]",
    "thumbnail": "Optional[Dict[str, Any]]",
}, total=False)

# required: message_id, chat, from, date, text
Message = TypedDict("Message", {
    "message_id": "str",
    "chat": "Chat",
    "from": "User",
    "date": "float",
    "edit_date": "float",
    "text": "str",
    "reply_to_message_id": "str",
    "attachments": "List[Attachment]",
    "embeds": "List[MessageEmbed]",
    "reply_markup": "InlineKeyboardMarkup",
}, total=False)

# required: message_id, chat, date
MessageDeleted = TypedDict("MessageDeleted", {
    "message_id": "str",
    "chat": "Chat",
    "date": "float",
}, total=False)

# required: —
MessageEmbed = TypedDict("MessageEmbed", {
    "title": "str",
    "url": "str",
    "description": "str",
    "color": "float",
    "timestamp": "str",
    "author": "Dict[str, Any]",
    "footer": "Dict[str, Any]",
    "fields": "List[Dict[str, Any]]",
    "image": "Dict[str, Any]",
    "thumbnail": "Dict[str, Any]",
    "imageLink": "str",
    "thumbnailLink": "str",
}, total=False)

# required: chat, message_id, user, date, old_reaction, new_reaction
MessageReactionUpdated = TypedDict("MessageReactionUpdated", {
    "chat": "Chat",
    "message_id": "str",
    "user": "User",
    "date": "float",
    "old_reaction": "List[ReactionType]",
    "new_reaction": "List[ReactionType]",
}, total=False)

# required: type, emoji
ReactionType = TypedDict("ReactionType", {
    "type": "Literal[\"emoji\"]",
    "emoji": "str",
}, total=False)

# required: id, title
ServerBrief = TypedDict("ServerBrief", {
    "id": "str",
    "title": "str",
}, total=False)

# required: id, title, channels, roles
ServerInfo = TypedDict("ServerInfo", {
    "id": "str",
    "title": "str",
    "channels": "List[Dict[str, Any]]",
    "roles": "List[Dict[str, Any]]",
}, total=False)

# required: chat, from, user, date, old_status, new_status
ServerMemberUpdated = TypedDict("ServerMemberUpdated", {
    "chat": "Chat",
    "from": "User",
    "user": "User",
    "date": "float",
    "old_status": "Literal[\"creator\", \"member\", \"left\", \"kicked\"]",
    "new_status": "Literal[\"creator\", \"member\", \"left\", \"kicked\"]",
}, total=False)

# required: update_id
Update = TypedDict("Update", {
    "update_id": "float",
    "message": "Message",
    "edited_message": "Message",
    "message_deleted": "MessageDeleted",
    "my_chat_member": "ChatMemberUpdated",
    "callback_query": "CallbackQuery",
    "message_reaction": "MessageReactionUpdated",
    "chat_member": "ServerMemberUpdated",
    "voice_state": "VoiceStateUpdated",
}, total=False)

# required: id, username, display_name, bot
User = TypedDict("User", {
    "id": "str",
    "username": "str",
    "display_name": "str",
    "bot": "bool",
    "instance_domain": "str",
}, total=False)

# required: user, muted, deafened, server_muted, is_bot
VoiceChatMember = TypedDict("VoiceChatMember", {
    "user": "User",
    "muted": "bool",
    "deafened": "bool",
    "server_muted": "bool",
    "is_bot": "bool",
}, total=False)

# required: url, token, room, chat, server_muted, expires_in, audio
VoiceJoinResult = TypedDict("VoiceJoinResult", {
    "url": "str",
    "token": "str",
    "room": "str",
    "chat": "Chat",
    "server_muted": "bool",
    "expires_in": "float",
    "audio": "Dict[str, Any]",
}, total=False)

# required: chat, user, action, date
VoiceStateUpdated = TypedDict("VoiceStateUpdated", {
    "chat": "Chat",
    "user": "User",
    "action": "Literal[\"joined\", \"left\"]",
    "date": "float",
    "move_to": "Chat",
}, total=False)

# required: url, pending_update_count, failures
WebhookInfo = TypedDict("WebhookInfo", {
    "url": "str",
    "pending_update_count": "float",
    "failures": "float",
    "last_error_date": "float",
    "last_error_message": "str",
    "disabled_date": "float",
    "batch": "bool",
    "dropped_update_count": "float",
}, total=False)


def _params(params: Dict[str, Any], extra: Dict[str, Any]) -> Dict[str, Any]:
    out = {k: v for k, v in params.items() if v is not None}
    out.update(extra)
    return out


class GeneratedMethods:
    """One wrapper per Bot API method; `None` arguments are not sent. `**extra` passes parameters newer than this SDK."""

    def call(self, method: str, params: Optional[Dict[str, Any]] = None, *, files: Optional[Sequence[Any]] = None) -> Any:
        raise NotImplementedError

    def get_me(self, **extra: Any) -> BotUser:
        """`getMe` (API 1+)."""
        params: Dict[str, Any] = {}
        return self.call("getMe", _params(params, extra))

    def get_updates(self, *, offset: Optional[int] = None, limit: Optional[int] = None, timeout: Optional[int] = None, allowed_updates: Optional[List[str]] = None, **extra: Any) -> List[Update]:
        """`getUpdates` (API 1+). Long polling: the request is held up to `timeout` seconds (at most 50)."""
        params: Dict[str, Any] = {"offset": offset, "limit": limit, "timeout": timeout, "allowed_updates": allowed_updates}
        return self.call("getUpdates", _params(params, extra))

    def set_webhook(self, url: str, secret_token: str, *, drop_pending_updates: Optional[bool] = None, batch: Optional[bool] = None, **extra: Any) -> bool:
        """`setWebhook` (API 1+)."""
        params: Dict[str, Any] = {"url": url, "secret_token": secret_token, "drop_pending_updates": drop_pending_updates, "batch": batch}
        return self.call("setWebhook", _params(params, extra))

    def delete_webhook(self, *, drop_pending_updates: Optional[bool] = None, **extra: Any) -> bool:
        """`deleteWebhook` (API 1+)."""
        params: Dict[str, Any] = {"drop_pending_updates": drop_pending_updates}
        return self.call("deleteWebhook", _params(params, extra))

    def get_webhook_info(self, **extra: Any) -> WebhookInfo:
        """`getWebhookInfo` (API 1+)."""
        params: Dict[str, Any] = {}
        return self.call("getWebhookInfo", _params(params, extra))

    def send_message(self, chat_id: str, text: Optional[str] = None, *, reply_to_message_id: Optional[str] = None, embeds: Optional[List[InputEmbed]] = None, disable_notification: Optional[bool] = None, disable_link_preview: Optional[bool] = None, reply_markup: Optional[InlineKeyboardMarkup] = None, client_id: Optional[str] = None, parse_mode: Optional[str] = None, files: Optional[Sequence[Any]] = None, **extra: Any) -> Message:
        """`sendMessage` (API 1+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "text": text, "reply_to_message_id": reply_to_message_id, "embeds": embeds, "disable_notification": disable_notification, "disable_link_preview": disable_link_preview, "reply_markup": reply_markup, "client_id": client_id, "parse_mode": parse_mode}
        return self.call("sendMessage", _params(params, extra), files=files)

    def edit_message_text(self, chat_id: str, message_id: str, text: str, *, reply_markup: Optional[InlineKeyboardMarkup] = None, parse_mode: Optional[str] = None, **extra: Any) -> Message:
        """`editMessageText` (API 1+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "message_id": message_id, "text": text, "reply_markup": reply_markup, "parse_mode": parse_mode}
        return self.call("editMessageText", _params(params, extra))

    def delete_message(self, chat_id: str, message_id: str, **extra: Any) -> bool:
        """`deleteMessage` (API 1+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "message_id": message_id}
        return self.call("deleteMessage", _params(params, extra))

    def send_chat_action(self, chat_id: str, action: Literal["typing"], **extra: Any) -> bool:
        """`sendChatAction` (API 1+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "action": action}
        return self.call("sendChatAction", _params(params, extra))

    def get_chat(self, chat_id: str, **extra: Any) -> ChatFullInfo:
        """`getChat` (API 1+)."""
        params: Dict[str, Any] = {"chat_id": chat_id}
        return self.call("getChat", _params(params, extra))

    def edit_message_reply_markup(self, chat_id: str, message_id: str, *, reply_markup: Optional[InlineKeyboardMarkup] = None, **extra: Any) -> Message:
        """`editMessageReplyMarkup` (API 2+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "message_id": message_id, "reply_markup": reply_markup}
        return self.call("editMessageReplyMarkup", _params(params, extra))

    def answer_callback_query(self, callback_query_id: str, text: Optional[str] = None, *, show_alert: Optional[bool] = None, **extra: Any) -> bool:
        """`answerCallbackQuery` (API 2+)."""
        params: Dict[str, Any] = {"callback_query_id": callback_query_id, "text": text, "show_alert": show_alert}
        return self.call("answerCallbackQuery", _params(params, extra))

    def set_my_commands(self, commands: List[BotCommand], *, scope: Optional[BotCommandScope] = None, **extra: Any) -> bool:
        """`setMyCommands` (API 2+)."""
        params: Dict[str, Any] = {"commands": commands, "scope": scope}
        return self.call("setMyCommands", _params(params, extra))

    def get_my_commands(self, *, scope: Optional[BotCommandScope] = None, **extra: Any) -> List[BotCommand]:
        """`getMyCommands` (API 2+)."""
        params: Dict[str, Any] = {"scope": scope}
        return self.call("getMyCommands", _params(params, extra))

    def delete_my_commands(self, *, scope: Optional[BotCommandScope] = None, **extra: Any) -> bool:
        """`deleteMyCommands` (API 2+)."""
        params: Dict[str, Any] = {"scope": scope}
        return self.call("deleteMyCommands", _params(params, extra))

    def set_message_reaction(self, chat_id: str, message_id: str, *, reaction: Optional[List[ReactionType]] = None, **extra: Any) -> bool:
        """`setMessageReaction` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "message_id": message_id, "reaction": reaction}
        return self.call("setMessageReaction", _params(params, extra))

    def pin_chat_message(self, chat_id: str, message_id: str, *, disable_notification: Optional[bool] = None, **extra: Any) -> bool:
        """`pinChatMessage` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "message_id": message_id, "disable_notification": disable_notification}
        return self.call("pinChatMessage", _params(params, extra))

    def unpin_chat_message(self, chat_id: str, message_id: str, **extra: Any) -> bool:
        """`unpinChatMessage` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "message_id": message_id}
        return self.call("unpinChatMessage", _params(params, extra))

    def get_chat_history(self, chat_id: str, *, before_message_id: Optional[str] = None, limit: Optional[int] = None, **extra: Any) -> List[Message]:
        """`getChatHistory` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "before_message_id": before_message_id, "limit": limit}
        return self.call("getChatHistory", _params(params, extra))

    def get_chat_member(self, chat_id: str, user_id: str, **extra: Any) -> ChatMember:
        """`getChatMember` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "user_id": user_id}
        return self.call("getChatMember", _params(params, extra))

    def get_chat_member_count(self, chat_id: str, **extra: Any) -> int:
        """`getChatMemberCount` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id}
        return self.call("getChatMemberCount", _params(params, extra))

    def get_chat_members(self, chat_id: str, *, offset: Optional[str] = None, limit: Optional[int] = None, **extra: Any) -> ChatMembersPage:
        """`getChatMembers` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "offset": offset, "limit": limit}
        return self.call("getChatMembers", _params(params, extra))

    def get_my_servers(self, **extra: Any) -> List[ServerBrief]:
        """`getMyServers` (API 3+)."""
        params: Dict[str, Any] = {}
        return self.call("getMyServers", _params(params, extra))

    def get_server(self, server_id: str, **extra: Any) -> ServerInfo:
        """`getServer` (API 3+)."""
        params: Dict[str, Any] = {"server_id": server_id}
        return self.call("getServer", _params(params, extra))

    def add_chat_member_role(self, chat_id: str, user_id: str, role_id: str, **extra: Any) -> bool:
        """`addChatMemberRole` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "user_id": user_id, "role_id": role_id}
        return self.call("addChatMemberRole", _params(params, extra))

    def remove_chat_member_role(self, chat_id: str, user_id: str, role_id: str, **extra: Any) -> bool:
        """`removeChatMemberRole` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "user_id": user_id, "role_id": role_id}
        return self.call("removeChatMemberRole", _params(params, extra))

    def ban_chat_member(self, chat_id: str, user_id: str, *, reason: Optional[str] = None, **extra: Any) -> bool:
        """`banChatMember` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "user_id": user_id, "reason": reason}
        return self.call("banChatMember", _params(params, extra))

    def unban_chat_member(self, chat_id: str, user_id: str, **extra: Any) -> bool:
        """`unbanChatMember` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "user_id": user_id}
        return self.call("unbanChatMember", _params(params, extra))

    def kick_chat_member(self, chat_id: str, user_id: str, **extra: Any) -> bool:
        """`kickChatMember` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "user_id": user_id}
        return self.call("kickChatMember", _params(params, extra))

    def leave_chat(self, chat_id: str, **extra: Any) -> bool:
        """`leaveChat` (API 3+)."""
        params: Dict[str, Any] = {"chat_id": chat_id}
        return self.call("leaveChat", _params(params, extra))

    def join_voice(self, chat_id: str, *, bitrate: Optional[int] = None, **extra: Any) -> VoiceJoinResult:
        """`joinVoice` (API 4+)."""
        params: Dict[str, Any] = {"chat_id": chat_id, "bitrate": bitrate}
        return self.call("joinVoice", _params(params, extra))

    def leave_voice(self, *, chat_id: Optional[str] = None, **extra: Any) -> bool:
        """`leaveVoice` (API 4+)."""
        params: Dict[str, Any] = {"chat_id": chat_id}
        return self.call("leaveVoice", _params(params, extra))

    def get_voice_chat_members(self, chat_id: str, **extra: Any) -> List[VoiceChatMember]:
        """`getVoiceChatMembers` (API 4+)."""
        params: Dict[str, Any] = {"chat_id": chat_id}
        return self.call("getVoiceChatMembers", _params(params, extra))