add_sticker_to_set(
  user_id :: integer(),
  name :: String.t(),
  emojis :: String.t(),
  options :: [
    png_sticker:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    tgs_sticker:
      {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
    mask_position: ExGram.Model.MaskPosition.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

add_sticker_to_set!(
  user_id :: integer(),
  name :: String.t(),
  emojis :: String.t(),
  ops :: [
    png_sticker:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    tgs_sticker:
      {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
    mask_position: ExGram.Model.MaskPosition.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

answer_callback_query(
  callback_query_id :: String.t(),
  options :: [
    text: String.t(),
    show_alert: boolean(),
    url: String.t(),
    cache_time: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

answer_callback_query!(
  callback_query_id :: String.t(),
  ops :: [
    text: String.t(),
    show_alert: boolean(),
    url: String.t(),
    cache_time: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

answer_inline_query(
  inline_query_id :: String.t(),
  results :: [ExGram.Model.InlineQueryResult.t()],
  options :: [
    cache_time: integer(),
    is_personal: boolean(),
    next_offset: String.t(),
    switch_pm_text: String.t(),
    switch_pm_parameter: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

answer_inline_query!(
  inline_query_id :: String.t(),
  results :: [ExGram.Model.InlineQueryResult.t()],
  ops :: [
    cache_time: integer(),
    is_personal: boolean(),
    next_offset: String.t(),
    switch_pm_text: String.t(),
    switch_pm_parameter: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

answer_pre_checkout_query(
  pre_checkout_query_id :: String.t(),
  ok :: boolean(),
  options :: [
    error_message: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

answer_pre_checkout_query!(
  pre_checkout_query_id :: String.t(),
  ok :: boolean(),
  ops :: [
    error_message: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

answer_shipping_query(
  shipping_query_id :: String.t(),
  ok :: boolean(),
  options :: [
    shipping_options: [ExGram.Model.ShippingOption.t()],
    error_message: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

answer_shipping_query!(
  shipping_query_id :: String.t(),
  ok :: boolean(),
  ops :: [
    shipping_options: [ExGram.Model.ShippingOption.t()],
    error_message: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

close(
  chat_id :: integer() | String.t(),
  text :: String.t(),
  options :: [
    parse_mode: String.t(),
    entities: [ExGram.Model.MessageEntity.t()],
    disable_web_page_preview: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

close!(
  chat_id :: integer() | String.t(),
  text :: String.t(),
  ops :: [
    parse_mode: String.t(),
    entities: [ExGram.Model.MessageEntity.t()],
    disable_web_page_preview: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

copy_message(
  chat_id :: integer() | String.t(),
  from_chat_id :: integer() | String.t(),
  message_id :: integer(),
  options :: [
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.MessageId.t()} | {:error, ExGram.Error.t()}

copy_message!(
  chat_id :: integer() | String.t(),
  from_chat_id :: integer() | String.t(),
  message_id :: integer(),
  ops :: [
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.MessageId.t()

create_new_sticker_set(
  user_id :: integer(),
  name :: String.t(),
  title :: String.t(),
  emojis :: String.t(),
  options :: [
    png_sticker:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    tgs_sticker:
      {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
    contains_masks: boolean(),
    mask_position: ExGram.Model.MaskPosition.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

create_new_sticker_set!(
  user_id :: integer(),
  name :: String.t(),
  title :: String.t(),
  emojis :: String.t(),
  ops :: [
    png_sticker:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    tgs_sticker:
      {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
    contains_masks: boolean(),
    mask_position: ExGram.Model.MaskPosition.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

delete_chat_photo(
  chat_id :: integer() | String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

delete_chat_photo!(
  chat_id :: integer() | String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

delete_chat_sticker_set(
  chat_id :: integer() | String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

delete_chat_sticker_set!(
  chat_id :: integer() | String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

delete_message(
  chat_id :: integer() | String.t(),
  message_id :: integer(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

delete_message!(
  chat_id :: integer() | String.t(),
  message_id :: integer(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

delete_sticker_from_set(
  sticker :: String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

delete_sticker_from_set!(
  sticker :: String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

delete_webhook(
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

delete_webhook!(
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

edit_message_caption(
  options :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

edit_message_caption!(
  ops :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

edit_message_live_location(
  latitude :: float(),
  longitude :: float(),
  options :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    horizontal_accuracy: float(),
    heading: integer(),
    proximity_alert_radius: integer(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

edit_message_live_location!(
  latitude :: float(),
  longitude :: float(),
  ops :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    horizontal_accuracy: float(),
    heading: integer(),
    proximity_alert_radius: integer(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

edit_message_media(
  media :: ExGram.Model.InputMedia.t(),
  options :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

edit_message_media!(
  media :: ExGram.Model.InputMedia.t(),
  ops :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

edit_message_reply_markup(
  options :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

edit_message_reply_markup!(
  ops :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

edit_message_text(
  text :: String.t(),
  options :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    parse_mode: String.t(),
    entities: [ExGram.Model.MessageEntity.t()],
    disable_web_page_preview: boolean(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

edit_message_text!(
  text :: String.t(),
  ops :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    parse_mode: String.t(),
    entities: [ExGram.Model.MessageEntity.t()],
    disable_web_page_preview: boolean(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

export_chat_invite_link(
  chat_id :: integer() | String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, String.t()} | {:error, ExGram.Error.t()}

export_chat_invite_link!(
  chat_id :: integer() | String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: String.t()

forward_message(
  chat_id :: integer() | String.t(),
  from_chat_id :: integer() | String.t(),
  message_id :: integer(),
  options :: [
    disable_notification: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

forward_message!(
  chat_id :: integer() | String.t(),
  from_chat_id :: integer() | String.t(),
  message_id :: integer(),
  ops :: [
    disable_notification: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

get_chat(
  chat_id :: integer() | String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Chat.t()} | {:error, ExGram.Error.t()}

get_chat!(
  chat_id :: integer() | String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Chat.t()

get_chat_administrators(
  chat_id :: integer() | String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.ChatMember.t()} | {:error, ExGram.Error.t()}

get_chat_administrators!(
  chat_id :: integer() | String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.ChatMember.t()

get_chat_member(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.ChatMember.t()} | {:error, ExGram.Error.t()}

get_chat_member!(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.ChatMember.t()

get_chat_members_count(
  chat_id :: integer() | String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, integer()} | {:error, ExGram.Error.t()}

get_chat_members_count!(
  chat_id :: integer() | String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: integer()

get_file(
  file_id :: String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.File.t()} | {:error, ExGram.Error.t()}

get_file!(
  file_id :: String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.File.t()

get_game_high_scores(
  user_id :: integer(),
  options :: [
    chat_id: integer(),
    message_id: integer(),
    inline_message_id: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.GameHighScore.t()} | {:error, ExGram.Error.t()}

get_game_high_scores!(
  user_id :: integer(),
  ops :: [
    chat_id: integer(),
    message_id: integer(),
    inline_message_id: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.GameHighScore.t()

get_me(
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.User.t()} | {:error, ExGram.Error.t()}

get_me!(
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.User.t()

get_my_commands(
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.BotCommand.t()} | {:error, ExGram.Error.t()}

get_my_commands!(
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.BotCommand.t()

get_sticker_set(
  name :: String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.StickerSet.t()} | {:error, ExGram.Error.t()}

get_sticker_set!(
  name :: String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.StickerSet.t()

get_updates(
  options :: [
    offset: integer(),
    limit: integer(),
    timeout: integer(),
    allowed_updates: [String.t()],
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Update.t()} | {:error, ExGram.Error.t()}

get_updates!(
  ops :: [
    offset: integer(),
    limit: integer(),
    timeout: integer(),
    allowed_updates: [String.t()],
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Update.t()

get_user_profile_photos(
  user_id :: integer(),
  options :: [
    offset: integer(),
    limit: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.UserProfilePhotos.t()} | {:error, ExGram.Error.t()}

get_user_profile_photos!(
  user_id :: integer(),
  ops :: [
    offset: integer(),
    limit: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.UserProfilePhotos.t()

get_webhook_info(
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.WebhookInfo.t()} | {:error, ExGram.Error.t()}

get_webhook_info!(
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.WebhookInfo.t()

kick_chat_member(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  options :: [
    until_date: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

kick_chat_member!(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  ops :: [
    until_date: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

leave_chat(
  chat_id :: integer() | String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

leave_chat!(
  chat_id :: integer() | String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

log_out(
  chat_id :: integer() | String.t(),
  text :: String.t(),
  options :: [
    parse_mode: String.t(),
    entities: [ExGram.Model.MessageEntity.t()],
    disable_web_page_preview: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

log_out!(
  chat_id :: integer() | String.t(),
  text :: String.t(),
  ops :: [
    parse_mode: String.t(),
    entities: [ExGram.Model.MessageEntity.t()],
    disable_web_page_preview: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

pin_chat_message(
  chat_id :: integer() | String.t(),
  message_id :: integer(),
  options :: [
    disable_notification: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

pin_chat_message!(
  chat_id :: integer() | String.t(),
  message_id :: integer(),
  ops :: [
    disable_notification: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

promote_chat_member(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  options :: [
    is_anonymous: boolean(),
    can_change_info: boolean(),
    can_post_messages: boolean(),
    can_edit_messages: boolean(),
    can_delete_messages: boolean(),
    can_invite_users: boolean(),
    can_restrict_members: boolean(),
    can_pin_messages: boolean(),
    can_promote_members: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

promote_chat_member!(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  ops :: [
    is_anonymous: boolean(),
    can_change_info: boolean(),
    can_post_messages: boolean(),
    can_edit_messages: boolean(),
    can_delete_messages: boolean(),
    can_invite_users: boolean(),
    can_restrict_members: boolean(),
    can_pin_messages: boolean(),
    can_promote_members: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

restrict_chat_member(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  permissions :: ExGram.Model.ChatPermissions.t(),
  options :: [
    until_date: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

restrict_chat_member!(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  permissions :: ExGram.Model.ChatPermissions.t(),
  ops :: [
    until_date: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

send_animation(
  chat_id :: integer() | String.t(),
  animation ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  options :: [
    duration: integer(),
    width: integer(),
    height: integer(),
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_animation!(
  chat_id :: integer() | String.t(),
  animation ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  ops :: [
    duration: integer(),
    width: integer(),
    height: integer(),
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_audio(
  chat_id :: integer() | String.t(),
  audio ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  options :: [
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    duration: integer(),
    performer: String.t(),
    title: String.t(),
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_audio!(
  chat_id :: integer() | String.t(),
  audio ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  ops :: [
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    duration: integer(),
    performer: String.t(),
    title: String.t(),
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_chat_action(
  chat_id :: integer() | String.t(),
  action :: String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

send_chat_action!(
  chat_id :: integer() | String.t(),
  action :: String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

send_contact(
  chat_id :: integer() | String.t(),
  phone_number :: String.t(),
  first_name :: String.t(),
  options :: [
    last_name: String.t(),
    vcard: String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_contact!(
  chat_id :: integer() | String.t(),
  phone_number :: String.t(),
  first_name :: String.t(),
  ops :: [
    last_name: String.t(),
    vcard: String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_dice(
  chat_id :: integer() | String.t(),
  options :: [
    emoji: String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_dice!(
  chat_id :: integer() | String.t(),
  ops :: [
    emoji: String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_document(
  chat_id :: integer() | String.t(),
  document ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  options :: [
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    disable_content_type_detection: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_document!(
  chat_id :: integer() | String.t(),
  document ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  ops :: [
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    disable_content_type_detection: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_game(
  chat_id :: integer(),
  game_short_name :: String.t(),
  options :: [
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_game!(
  chat_id :: integer(),
  game_short_name :: String.t(),
  ops :: [
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_invoice(
  chat_id :: integer(),
  title :: String.t(),
  description :: String.t(),
  payload :: String.t(),
  provider_token :: String.t(),
  start_parameter :: String.t(),
  currency :: String.t(),
  prices :: [ExGram.Model.LabeledPrice.t()],
  options :: [
    provider_data: String.t(),
    photo_url: String.t(),
    photo_size: integer(),
    photo_width: integer(),
    photo_height: integer(),
    need_name: boolean(),
    need_phone_number: boolean(),
    need_email: boolean(),
    need_shipping_address: boolean(),
    send_phone_number_to_provider: boolean(),
    send_email_to_provider: boolean(),
    is_flexible: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_invoice!(
  chat_id :: integer(),
  title :: String.t(),
  description :: String.t(),
  payload :: String.t(),
  provider_token :: String.t(),
  start_parameter :: String.t(),
  currency :: String.t(),
  prices :: [ExGram.Model.LabeledPrice.t()],
  ops :: [
    provider_data: String.t(),
    photo_url: String.t(),
    photo_size: integer(),
    photo_width: integer(),
    photo_height: integer(),
    need_name: boolean(),
    need_phone_number: boolean(),
    need_email: boolean(),
    need_shipping_address: boolean(),
    send_phone_number_to_provider: boolean(),
    send_email_to_provider: boolean(),
    is_flexible: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_location(
  chat_id :: integer() | String.t(),
  latitude :: float(),
  longitude :: float(),
  options :: [
    horizontal_accuracy: float(),
    live_period: integer(),
    heading: integer(),
    proximity_alert_radius: integer(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_location!(
  chat_id :: integer() | String.t(),
  latitude :: float(),
  longitude :: float(),
  ops :: [
    horizontal_accuracy: float(),
    live_period: integer(),
    heading: integer(),
    proximity_alert_radius: integer(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_media_group(
  chat_id :: integer() | String.t(),
  media :: [
    ExGram.Model.InputMediaAudio.t()
    | ExGram.Model.InputMediaDocument.t()
    | ExGram.Model.InputMediaPhoto.t()
    | ExGram.Model.InputMediaVideo.t()
  ],
  options :: [
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_media_group!(
  chat_id :: integer() | String.t(),
  media :: [
    ExGram.Model.InputMediaAudio.t()
    | ExGram.Model.InputMediaDocument.t()
    | ExGram.Model.InputMediaPhoto.t()
    | ExGram.Model.InputMediaVideo.t()
  ],
  ops :: [
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_message(
  chat_id :: integer() | String.t(),
  text :: String.t(),
  options :: [
    parse_mode: String.t(),
    entities: [ExGram.Model.MessageEntity.t()],
    disable_web_page_preview: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_message!(
  chat_id :: integer() | String.t(),
  text :: String.t(),
  ops :: [
    parse_mode: String.t(),
    entities: [ExGram.Model.MessageEntity.t()],
    disable_web_page_preview: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_photo(
  chat_id :: integer() | String.t(),
  photo ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  options :: [
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_photo!(
  chat_id :: integer() | String.t(),
  photo ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  ops :: [
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_poll(
  chat_id :: integer() | String.t(),
  question :: String.t(),
  options :: [String.t()],
  options :: [
    is_anonymous: boolean(),
    type: String.t(),
    allows_multiple_answers: boolean(),
    correct_option_id: integer(),
    explanation: String.t(),
    explanation_parse_mode: String.t(),
    explanation_entities: [ExGram.Model.MessageEntity.t()],
    open_period: integer(),
    close_date: integer(),
    is_closed: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_poll!(
  chat_id :: integer() | String.t(),
  question :: String.t(),
  options :: [String.t()],
  ops :: [
    is_anonymous: boolean(),
    type: String.t(),
    allows_multiple_answers: boolean(),
    correct_option_id: integer(),
    explanation: String.t(),
    explanation_parse_mode: String.t(),
    explanation_entities: [ExGram.Model.MessageEntity.t()],
    open_period: integer(),
    close_date: integer(),
    is_closed: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_sticker(
  chat_id :: integer() | String.t(),
  sticker ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  options :: [
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_sticker!(
  chat_id :: integer() | String.t(),
  sticker ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  ops :: [
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_venue(
  chat_id :: integer() | String.t(),
  latitude :: float(),
  longitude :: float(),
  title :: String.t(),
  address :: String.t(),
  options :: [
    foursquare_id: String.t(),
    foursquare_type: String.t(),
    google_place_id: String.t(),
    google_place_type: String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_venue!(
  chat_id :: integer() | String.t(),
  latitude :: float(),
  longitude :: float(),
  title :: String.t(),
  address :: String.t(),
  ops :: [
    foursquare_id: String.t(),
    foursquare_type: String.t(),
    google_place_id: String.t(),
    google_place_type: String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_video(
  chat_id :: integer() | String.t(),
  video ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  options :: [
    duration: integer(),
    width: integer(),
    height: integer(),
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    supports_streaming: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_video!(
  chat_id :: integer() | String.t(),
  video ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  ops :: [
    duration: integer(),
    width: integer(),
    height: integer(),
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    supports_streaming: boolean(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_video_note(
  chat_id :: integer() | String.t(),
  video_note ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  options :: [
    duration: integer(),
    length: integer(),
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_video_note!(
  chat_id :: integer() | String.t(),
  video_note ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  ops :: [
    duration: integer(),
    length: integer(),
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

send_voice(
  chat_id :: integer() | String.t(),
  voice ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  options :: [
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    duration: integer(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

send_voice!(
  chat_id :: integer() | String.t(),
  voice ::
    {:file, String.t()}
    | {:file_content, iodata() | Enum.t(), String.t()}
    | String.t(),
  ops :: [
    caption: String.t(),
    parse_mode: String.t(),
    caption_entities: [ExGram.Model.MessageEntity.t()],
    duration: integer(),
    disable_notification: boolean(),
    reply_to_message_id: integer(),
    allow_sending_without_reply: boolean(),
    reply_markup:
      ExGram.Model.InlineKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardMarkup.t()
      | ExGram.Model.ReplyKeyboardRemove.t()
      | ExGram.Model.ForceReply.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

set_chat_administrator_custom_title(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  custom_title :: String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_chat_administrator_custom_title!(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  custom_title :: String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_chat_description(
  chat_id :: integer() | String.t(),
  options :: [
    description: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_chat_description!(
  chat_id :: integer() | String.t(),
  ops :: [
    description: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_chat_permissions(
  chat_id :: integer() | String.t(),
  permissions :: ExGram.Model.ChatPermissions.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_chat_permissions!(
  chat_id :: integer() | String.t(),
  permissions :: ExGram.Model.ChatPermissions.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_chat_photo(
  chat_id :: integer() | String.t(),
  photo ::
    {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_chat_photo!(
  chat_id :: integer() | String.t(),
  photo ::
    {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_chat_sticker_set(
  chat_id :: integer() | String.t(),
  sticker_set_name :: String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_chat_sticker_set!(
  chat_id :: integer() | String.t(),
  sticker_set_name :: String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_chat_title(
  chat_id :: integer() | String.t(),
  title :: String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_chat_title!(
  chat_id :: integer() | String.t(),
  title :: String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_game_score(
  user_id :: integer(),
  score :: integer(),
  options :: [
    force: boolean(),
    disable_edit_message: boolean(),
    chat_id: integer(),
    message_id: integer(),
    inline_message_id: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

set_game_score!(
  user_id :: integer(),
  score :: integer(),
  ops :: [
    force: boolean(),
    disable_edit_message: boolean(),
    chat_id: integer(),
    message_id: integer(),
    inline_message_id: String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

set_my_commands(
  commands :: [ExGram.Model.BotCommand.t()],
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_my_commands!(
  commands :: [ExGram.Model.BotCommand.t()],
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_passport_data_errors(
  user_id :: integer(),
  errors :: [ExGram.Model.PassportElementError.t()],
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_passport_data_errors!(
  user_id :: integer(),
  errors :: [ExGram.Model.PassportElementError.t()],
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_sticker_position_in_set(
  sticker :: String.t(),
  position :: integer(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_sticker_position_in_set!(
  sticker :: String.t(),
  position :: integer(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_sticker_set_thumb(
  name :: String.t(),
  user_id :: integer(),
  options :: [
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_sticker_set_thumb!(
  name :: String.t(),
  user_id :: integer(),
  ops :: [
    thumb:
      {:file, String.t()}
      | {:file_content, iodata() | Enum.t(), String.t()}
      | String.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

set_webhook(
  url :: String.t(),
  options :: [
    certificate:
      {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
    ip_address: String.t(),
    max_connections: integer(),
    allowed_updates: [String.t()],
    drop_pending_updates: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

set_webhook!(
  url :: String.t(),
  ops :: [
    certificate:
      {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
    ip_address: String.t(),
    max_connections: integer(),
    allowed_updates: [String.t()],
    drop_pending_updates: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

stop_message_live_location(
  options :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Message.t()} | {:error, ExGram.Error.t()}

stop_message_live_location!(
  ops :: [
    chat_id: integer() | String.t(),
    message_id: integer(),
    inline_message_id: String.t(),
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Message.t()

stop_poll(
  chat_id :: integer() | String.t(),
  message_id :: integer(),
  options :: [
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.Poll.t()} | {:error, ExGram.Error.t()}

stop_poll!(
  chat_id :: integer() | String.t(),
  message_id :: integer(),
  ops :: [
    reply_markup: ExGram.Model.InlineKeyboardMarkup.t(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.Poll.t()

unban_chat_member(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  options :: [
    only_if_banned: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

unban_chat_member!(
  chat_id :: integer() | String.t(),
  user_id :: integer(),
  ops :: [
    only_if_banned: boolean(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

unpin_all_chat_messages(
  chat_id :: integer() | String.t(),
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

unpin_all_chat_messages!(
  chat_id :: integer() | String.t(),
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

unpin_chat_message(
  chat_id :: integer() | String.t(),
  options :: [
    message_id: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, true} | {:error, ExGram.Error.t()}

unpin_chat_message!(
  chat_id :: integer() | String.t(),
  ops :: [
    message_id: integer(),
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: true

upload_sticker_file(
  user_id :: integer(),
  png_sticker ::
    {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
  options :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: {:ok, ExGram.Model.File.t()} | {:error, ExGram.Error.t()}

upload_sticker_file!(
  user_id :: integer(),
  png_sticker ::
    {:file, String.t()} | {:file_content, iodata() | Enum.t(), String.t()},
  ops :: [
    adapter: atom(),
    bot: atom(),
    token: String.t(),
    debug: boolean(),
    check_params: boolean()
  ]
) :: ExGram.Model.File.t()