grammerb 0.1.0-x86_64-linux

data/lib/grammerb/types.rb

@@ -0,0 +1,530 @@
+# lib/grammerb/types.rb
+module Grammerb
+  module Types
+    class Button
+      attr_reader :text, :callback_data, :url, :switch_inline, :web_app_url
+
+      def initialize(hash)
+        @text = hash[:text]
+        @callback_data = hash[:callback_data]
+        @url = hash[:url]
+        @switch_inline = hash[:switch_inline]
+        @web_app_url = hash[:web_app_url]
+      end
+
+      def callback?
+        !@callback_data.nil?
+      end
+
+      def url?
+        !@url.nil?
+      end
+
+      def web_app?
+        !@web_app_url.nil?
+      end
+
+      def data_str
+        @data_str_cache ||= @callback_data&.pack("C*")&.force_encoding("UTF-8")
+      end
+
+      def ==(other)
+        other.is_a?(Button) && @text == other.text && @callback_data == other.callback_data &&
+          @url == other.url && @switch_inline == other.switch_inline && @web_app_url == other.web_app_url
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [@text, @callback_data, @url, @switch_inline, @web_app_url].hash
+      end
+
+      def to_h
+        { text: @text, callback_data: @callback_data, url: @url, switch_inline: @switch_inline, web_app_url: @web_app_url }.compact
+      end
+
+      def to_s
+        @text.to_s
+      end
+    end
+
+    class Message
+      attr_reader :id, :text, :chat_id, :chat_name, :sender_id, :sender_name, :date,
+                  :chat_type, :grouped_id, :reply_to_message_id, :buttons,
+                  :media_type, :media_id, :media_file_name, :media_mime_type,
+                  :media_size, :media_duration, :media_width, :media_height,
+                  :media_sticker_emoji
+      attr_accessor :client, :raw
+
+      def initialize(hash)
+        @raw = hash
+        @id = hash[:id] || hash[:message_id]
+        @text = hash[:text] || hash[:message_text]
+        @chat_id = hash[:chat_id]
+        @chat_name = hash[:chat_name]
+        @sender_id = hash[:sender_id]
+        @sender_name = hash[:sender_name]
+        @date = hash[:date] ? Time.at(hash[:date]) : nil
+        @chat_type = hash[:chat_type]
+        @grouped_id = hash[:grouped_id]
+        @reply_to_message_id = hash[:reply_to_message_id]
+        # Media
+        @media_type = hash[:media_type]
+        @media_id = hash[:media_id]
+        @media_file_name = hash[:media_file_name]
+        @media_mime_type = hash[:media_mime_type]
+        @media_size = hash[:media_size]
+        @media_duration = hash[:media_duration]
+        @media_width = hash[:media_width]
+        @media_height = hash[:media_height]
+        @media_sticker_emoji = hash[:media_sticker_emoji]
+        # Buttons
+        @buttons = (hash[:buttons] || []).map do |row|
+          row.map { |b| Button.new(b) }
+        end
+      end
+
+      def has_buttons?
+        !@buttons.empty?
+      end
+
+      def has_media?
+        !@media_type.nil?
+      end
+
+      def photo?
+        @media_type == "photo"
+      end
+
+      def document?
+        @media_type == "document"
+      end
+
+      def sticker?
+        @media_type == "sticker"
+      end
+
+      def poll?
+        @media_type == "poll"
+      end
+
+      def album?
+        !@grouped_id.nil?
+      end
+
+      def peer_id
+        @chat_id.to_s
+      end
+
+      # Action methods (require client to be set)
+      def reply(text, **opts)
+        @client&.send_message(chat_id, text, reply_to: id, **opts)
+      end
+
+      def edit(new_text, parse_mode: nil, buttons: nil, reply_markup: nil)
+        @client&.edit_message(chat_id, id, new_text, parse_mode: parse_mode, buttons: buttons, reply_markup: reply_markup)
+      end
+
+      def delete
+        @client&.delete_messages(chat_id, id)
+      end
+
+      def forward(to_chat)
+        @client&.forward_messages(chat_id, [id], to_chat)
+      end
+
+      def pin
+        @client&.pin_message(chat_id, id)
+      end
+
+      def download(path, &progress)
+        @client&.download_media(chat_id, id, path, &progress)
+      end
+
+      def ==(other)
+        other.is_a?(Message) && @id == other.id && @chat_id == other.chat_id
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [@id, @chat_id].hash
+      end
+
+      def to_h
+        { id: @id, text: @text, chat_id: @chat_id, chat_name: @chat_name,
+          sender_id: @sender_id, sender_name: @sender_name,
+          date: @date, chat_type: @chat_type, grouped_id: @grouped_id,
+          reply_to_message_id: @reply_to_message_id,
+          media_type: @media_type, media_id: @media_id,
+          media_file_name: @media_file_name, media_mime_type: @media_mime_type,
+          media_size: @media_size, media_duration: @media_duration,
+          media_width: @media_width, media_height: @media_height,
+          media_sticker_emoji: @media_sticker_emoji,
+          buttons: @buttons.map { |row| row.map(&:to_h) } }.compact
+      end
+
+      def to_s
+        text.to_s
+      end
+    end
+
+    class User
+      attr_reader :id, :first_name, :last_name, :username, :phone, :bot
+
+      def initialize(hash)
+        @id = hash[:id]
+        @first_name = hash[:first_name]
+        @last_name = hash[:last_name]
+        @username = hash[:username]
+        @phone = hash[:phone]
+        @bot = hash[:bot]
+      end
+
+      def bot?
+        @bot
+      end
+
+      def full_name
+        [@first_name, @last_name].compact.join(" ")
+      end
+
+      def peer_id
+        @id.to_s
+      end
+
+      def ==(other)
+        other.is_a?(User) && @id == other.id
+      end
+      alias_method :eql?, :==
+
+      def hash
+        @id.hash
+      end
+
+      def to_h
+        { id: @id, first_name: @first_name, last_name: @last_name, username: @username, phone: @phone, bot: @bot }.compact
+      end
+
+      def to_s
+        full_name
+      end
+    end
+
+    class Dialog
+      attr_reader :name, :id, :peer_type, :unread_count, :last_message_text
+
+      def initialize(hash)
+        @name = hash[:name]
+        @id = hash[:id]
+        @peer_type = hash[:peer_type]
+        @unread_count = hash[:unread_count]
+        @last_message_text = hash[:last_message_text]
+      end
+
+      def peer_id
+        @id.to_s
+      end
+
+      def ==(other)
+        other.is_a?(Dialog) && @id == other.id
+      end
+      alias_method :eql?, :==
+
+      def hash
+        @id.hash
+      end
+
+      def to_h
+        { name: @name, id: @id, peer_type: @peer_type, unread_count: @unread_count, last_message_text: @last_message_text }.compact
+      end
+
+      def to_s
+        name.to_s
+      end
+    end
+
+    class Participant
+      attr_reader :id, :first_name, :last_name, :username
+
+      def initialize(hash)
+        @id = hash[:id]
+        @first_name = hash[:first_name]
+        @last_name = hash[:last_name]
+        @username = hash[:username]
+      end
+
+      def full_name
+        [@first_name, @last_name].compact.join(" ")
+      end
+
+      def peer_id
+        @id.to_s
+      end
+
+      def ==(other)
+        other.is_a?(Participant) && @id == other.id
+      end
+      alias_method :eql?, :==
+
+      def hash
+        @id.hash
+      end
+
+      def to_h
+        { id: @id, first_name: @first_name, last_name: @last_name, username: @username }.compact
+      end
+
+      def to_s
+        full_name
+      end
+    end
+
+    class Peer
+      attr_reader :id, :name, :peer_type
+
+      def initialize(hash)
+        @id = hash[:id]
+        @name = hash[:name]
+        @peer_type = hash[:peer_type]
+      end
+
+      def peer_id
+        @id.to_s
+      end
+
+      def ==(other)
+        other.is_a?(Peer) && @id == other.id
+      end
+      alias_method :eql?, :==
+
+      def hash
+        @id.hash
+      end
+
+      def to_h
+        { id: @id, name: @name, peer_type: @peer_type }.compact
+      end
+
+      def to_s
+        name.to_s
+      end
+    end
+
+    class Permissions
+      attr_reader :is_admin, :is_creator, :is_banned, :has_default_permissions
+
+      def initialize(hash)
+        @is_admin = hash[:is_admin]
+        @is_creator = hash[:is_creator]
+        @is_banned = hash[:is_banned]
+        @has_default_permissions = hash[:has_default_permissions]
+      end
+
+      def admin?
+        @is_admin
+      end
+
+      def creator?
+        @is_creator
+      end
+
+      def banned?
+        @is_banned
+      end
+
+      def ==(other)
+        other.is_a?(Permissions) && @is_admin == other.is_admin && @is_creator == other.is_creator && @is_banned == other.is_banned
+      end
+      alias_method :eql?, :==
+
+      def hash
+        [@is_admin, @is_creator, @is_banned].hash
+      end
+
+      def to_h
+        { is_admin: @is_admin, is_creator: @is_creator, is_banned: @is_banned, has_default_permissions: @has_default_permissions }
+      end
+    end
+
+    class PollResults
+      attr_reader :total_voters, :results, :solution
+
+      def initialize(hash)
+        @total_voters = hash[:total_voters]
+        @results = (hash[:results] || []).map { |r| PollOption.new(r) }
+        @solution = hash[:solution]
+      end
+
+      def to_h
+        { total_voters: @total_voters, results: @results.map(&:to_h), solution: @solution }.compact
+      end
+
+      def to_s
+        "PollResults(voters=#{@total_voters})"
+      end
+    end
+
+    class PollOption
+      attr_reader :option, :voters, :chosen, :correct
+
+      def initialize(hash)
+        @option = hash[:option]
+        @voters = hash[:voters]
+        @chosen = hash[:chosen]
+        @correct = hash[:correct]
+      end
+
+      def chosen?
+        @chosen
+      end
+
+      def correct?
+        @correct
+      end
+
+      def to_h
+        { option: @option, voters: @voters, chosen: @chosen, correct: @correct }
+      end
+
+      def to_s
+        "PollOption(voters=#{@voters})"
+      end
+    end
+
+    class PollVotes
+      attr_reader :count, :votes, :next_offset
+
+      def initialize(hash)
+        @count = hash[:count]
+        @votes = (hash[:votes] || []).map { |v| PollVote.new(v) }
+        @next_offset = hash[:next_offset]
+      end
+
+      def to_h
+        { count: @count, votes: @votes.map(&:to_h), next_offset: @next_offset }.compact
+      end
+
+      def to_s
+        "PollVotes(count=#{@count})"
+      end
+    end
+
+    class PollVote
+      attr_reader :peer_id, :options, :date
+
+      def initialize(hash)
+        @peer_id = hash[:peer_id]
+        @options = hash[:options] || []
+        @date = hash[:date] ? Time.at(hash[:date]) : nil
+      end
+
+      def to_h
+        { peer_id: @peer_id, options: @options, date: @date }
+      end
+
+      def to_s
+        "PollVote(peer=#{@peer_id})"
+      end
+    end
+
+    class Draft
+      attr_reader :peer_id, :text, :date, :reply_to_msg_id
+
+      def initialize(hash)
+        @peer_id = hash[:peer_id]
+        @text = hash[:text]
+        @date = hash[:date] ? Time.at(hash[:date]) : nil
+        @reply_to_msg_id = hash[:reply_to_msg_id]
+      end
+
+      def to_h
+        { peer_id: @peer_id, text: @text, date: @date, reply_to_msg_id: @reply_to_msg_id }.compact
+      end
+
+      def to_s
+        "Draft(peer=#{@peer_id}, #{@text&.slice(0, 30)})"
+      end
+    end
+
+    class AdminLogEvent
+      attr_reader :id, :date, :user_id, :action
+
+      def initialize(hash)
+        @id = hash[:id]
+        @date = hash[:date] ? Time.at(hash[:date]) : nil
+        @user_id = hash[:user_id]
+        @action = hash[:action]
+      end
+
+      def to_h
+        { id: @id, date: @date, user_id: @user_id, action: @action }
+      end
+
+      def to_s
+        "AdminLogEvent(#{@action}, user=#{@user_id})"
+      end
+    end
+
+    class InlineResult
+      attr_reader :id, :title, :description
+
+      def initialize(hash)
+        @id = hash[:id]
+        @title = hash[:title]
+        @description = hash[:description]
+      end
+
+      def to_h
+        { id: @id, title: @title, description: @description }.compact
+      end
+
+      def to_s
+        @title.to_s
+      end
+    end
+
+    class ChatFull
+      attr_reader :id, :about, :participants_count, :admins_count,
+                  :kicked_count, :banned_count, :online_count,
+                  :pinned_msg_id, :linked_chat_id, :slowmode_seconds,
+                  :can_view_participants, :can_set_username
+
+      def initialize(hash)
+        @id = hash[:id]
+        @about = hash[:about]
+        @participants_count = hash[:participants_count]
+        @admins_count = hash[:admins_count]
+        @kicked_count = hash[:kicked_count]
+        @banned_count = hash[:banned_count]
+        @online_count = hash[:online_count]
+        @pinned_msg_id = hash[:pinned_msg_id]
+        @linked_chat_id = hash[:linked_chat_id]
+        @slowmode_seconds = hash[:slowmode_seconds]
+        @can_view_participants = hash[:can_view_participants]
+        @can_set_username = hash[:can_set_username]
+      end
+
+      def ==(other)
+        other.is_a?(ChatFull) && @id == other.id
+      end
+      alias_method :eql?, :==
+
+      def hash
+        @id.hash
+      end
+
+      def to_h
+        { id: @id, about: @about, participants_count: @participants_count,
+          admins_count: @admins_count, kicked_count: @kicked_count,
+          banned_count: @banned_count, online_count: @online_count,
+          pinned_msg_id: @pinned_msg_id, linked_chat_id: @linked_chat_id,
+          slowmode_seconds: @slowmode_seconds,
+          can_view_participants: @can_view_participants,
+          can_set_username: @can_set_username }.compact
+      end
+
+      def to_s
+        "ChatFull(id=#{@id}, about=#{@about&.slice(0, 50)})"
+      end
+    end
+  end
+end

data/lib/grammerb/version.rb

@@ -0,0 +1,4 @@
+# lib/grammerb/version.rb
+module Grammerb
+  VERSION = "0.1.0"
+end

data/lib/grammerb.rb

@@ -0,0 +1,19 @@
+# lib/grammerb.rb
+require_relative "grammerb/version"
+
+begin
+  RUBY_VERSION =~ /(\d+\.\d+)/
+  require_relative "grammerb/#{$1}/grammerb"
+rescue LoadError
+  begin
+    require_relative "grammerb/grammerb"
+  rescue LoadError
+    raise LoadError, "Failed to load Grammerb native extension. Run `rake compile` first."
+  end
+end
+
+require_relative "grammerb/errors"
+require_relative "grammerb/types"
+require_relative "grammerb/events"
+require_relative "grammerb/conversation"
+require_relative "grammerb/client"

data/sig/grammerb/client.rbs

@@ -0,0 +1,145 @@
+module Grammerb
+  class HandlerPool
+    def initialize: (Integer size) -> void
+    def schedule: () { () -> void } -> void
+    def shutdown: () -> void
+  end
+
+  class Client
+    attr_reader native: untyped
+    attr_reader logger: Logger
+
+    def initialize: (api_id: Integer, api_hash: String, ?session: String, ?proxy: String?, ?logger: Logger?, ?pool_size: Integer) -> void
+
+    # --- Connection ---
+    def connect: () -> self
+    def disconnect: () -> void
+    def authorized?: () -> bool
+
+    # --- Auth ---
+    def start: (phone: String, ?code_callback: (^() -> String)?, ?password_callback: (^() -> String)?) -> self
+    def bot_start: (token: String) -> self
+    def sign_out: () -> void
+
+    # --- Messages ---
+    def send_message: (peer chat, String text, ?reply_to: Integer?, ?parse_mode: String?, ?silent: bool, ?link_preview: bool, ?schedule: Time?, ?comment_to: Integer?, ?send_as: peer?, ?buttons: button_rows?, ?reply_markup: reply_markup?) -> Types::Message
+    def edit_message: (peer chat, Integer message_id, String text, ?parse_mode: String?, ?link_preview: bool, ?buttons: button_rows?, ?reply_markup: reply_markup?) -> self
+    def delete_messages: (peer chat, *Integer message_ids, ?revoke: bool) -> void
+    def forward_messages: (peer from_chat, Array[Integer] message_ids, peer to_chat, ?silent: bool, ?schedule: Time?, ?drop_author: bool, ?noforwards: bool) -> Array[Types::Message?]
+    def get_messages: (peer chat, ?limit: Integer, ?offset_id: Integer?, ?offset_date: (Time | Integer)?) -> Array[Types::Message]
+    def get_messages_by_id: (peer chat, *Integer message_ids) -> Array[Types::Message?]
+    def pin_message: (peer chat, Integer message_id, ?notify: bool) -> void
+    def unpin_message: (peer chat, Integer message_id) -> void
+    def unpin_all_messages: (peer chat) -> void
+    def get_pinned_message: (peer chat) -> Types::Message?
+    def send_reactions: (peer chat, Integer message_id, *String reactions) -> void
+    def search_messages: (peer chat, ?query: String, ?limit: Integer, ?filter: String?, ?from_user: peer?) -> Array[Types::Message]
+    def search_all_messages: (?query: String, ?limit: Integer) -> Array[Types::Message]
+    def get_reply_to_message: (peer chat, Integer message_id) -> Types::Message?
+    def send_chat_action: (peer chat, String | Symbol action) -> void
+    def send_poll: (peer chat, String question, Array[String] answers, ?quiz: bool, ?correct_option: Integer?) -> Types::Message
+    def get_poll_results: (peer chat, Integer message_id) -> Types::PollResults
+    def get_poll_votes: (peer chat, Integer message_id, ?option: Integer?, ?limit: Integer) -> Types::PollVotes
+
+    # --- Dialogs ---
+    def iter_dialogs: (?limit: Integer) -> Array[Types::Dialog]
+    alias get_dialogs iter_dialogs
+    def delete_dialog: (peer chat) -> void
+    def mark_as_read: (peer chat) -> void
+    def send_read_acknowledge: (peer chat, ?untyped? message, ?max_id: Integer?) -> void
+    def iter_drafts: () -> Array[Types::Draft]
+    alias get_drafts iter_drafts
+    def clear_drafts: () -> void
+    def clear_mentions: (peer chat) -> void
+
+    # --- Users / Chats ---
+    def get_me: () -> Types::User
+    def get_entity: (peer entity) -> Types::Peer?
+    def edit_permissions: (peer chat, **bool rights) -> void
+    def resolve_username: (String username) -> Types::Peer?
+    def iter_participants: (peer chat, ?limit: Integer, ?filter: String?, ?search: String?, ?aggressive: bool) -> Array[Types::Participant]
+    alias get_participants iter_participants
+    def kick_participant: (peer chat, peer user) -> void
+    def set_admin_rights: (peer chat, peer user, **bool rights) -> void
+    def set_banned_rights: (peer chat, peer user, **bool rights) -> void
+    def get_permissions: (peer chat, peer user) -> Types::Permissions
+    def iter_profile_photos: (peer chat, ?limit: Integer) -> Array[untyped]
+    def join_chat: (peer chat) -> (Types::Peer | void)
+    def accept_invite_link: (String link) -> Types::Peer?
+    def download_profile_photo: (peer entity, String path) -> bool
+    def iter_admin_log: (peer chat, ?limit: Integer, ?query: String?, ?filter: Hash[Symbol, bool]?) -> Array[Types::AdminLogEvent]
+    alias get_admin_log iter_admin_log
+    def edit_title: (peer chat, String title) -> void
+    def edit_photo: (peer chat, String path) -> void
+    def get_stats: (peer chat) -> untyped
+    def export_invite_link: (peer chat) -> String
+    def block_user: (peer user) -> void
+    def unblock_user: (peer user) -> void
+    def create_group: (String title, Array[peer] users) -> Types::Peer
+    def create_channel: (String title, ?about: String) -> Types::Peer
+    def create_supergroup: (String title, ?about: String) -> Types::Peer
+    def edit_about: (peer chat, String about) -> void
+    def get_full_chat: (peer chat) -> Types::ChatFull
+
+    # --- Keyboards ---
+    def send_reply_keyboard: (peer chat, String text, Array[Array[String | Hash[Symbol, untyped]]] keys, ?parse_mode: String?, ?resize: bool, ?single_use: bool, ?placeholder: String?) -> Types::Message
+    def remove_keyboard: (peer chat, ?String text, ?parse_mode: String?) -> Types::Message
+    def force_reply: (peer chat, String text, ?parse_mode: String?) -> Types::Message
+
+    # --- Files ---
+    def send_file: (peer chat, String path, ?caption: String?, ?parse_mode: String?, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?buttons: button_rows?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_photo: (peer chat, String path, ?caption: String?, ?parse_mode: String?, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?buttons: button_rows?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_audio: (peer chat, String path, ?caption: String?, ?parse_mode: String?, ?duration: Integer, ?title: String?, ?performer: String?, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?buttons: button_rows?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_video: (peer chat, String path, ?caption: String?, ?parse_mode: String?, ?duration: Integer, ?width: Integer, ?height: Integer, ?supports_streaming: bool, ?round_message: bool, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?buttons: button_rows?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_voice: (peer chat, String path, ?caption: String?, ?parse_mode: String?, ?duration: Integer, ?waveform: String?, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?buttons: button_rows?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_album: (peer chat, *(String | Hash[Symbol, String]) media_items, ?reply_to: Integer?, ?silent: bool, ?buttons: button_rows?, ?reply_markup: reply_markup?) -> Array[Types::Message?]
+    def send_location: (peer chat, Float lat, Float long, ?accuracy_radius: Integer?, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_venue: (peer chat, Float lat, Float long, title: String, address: String, ?provider: String, ?venue_id: String, ?venue_type: String, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_contact: (peer chat, phone_number: String, first_name: String, ?last_name: String, ?vcard: String, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_dice: (peer chat, ?emoticon: String, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_sticker: (peer chat, String path, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?reply_markup: reply_markup?) -> Types::Message
+    def send_animation: (peer chat, String path, ?caption: String?, ?parse_mode: String?, ?duration: Integer, ?width: Integer, ?height: Integer, ?reply_to: Integer?, ?silent: bool, ?schedule: Time?, ?reply_markup: reply_markup?) -> Types::Message
+    def download_media: (peer chat, Integer message_id, String path) ?{ (Integer downloaded, Integer? total) -> void } -> void
+
+    # --- Bots ---
+    def inline_query: (peer bot, String query, ?limit: Integer) -> Array[Types::InlineResult]
+    def answer_callback_query: (Integer query_id, ?text: String?, ?alert: bool, ?cache_time: Integer?) -> void
+    def answer_inline_query: (Integer query_id, Array[Hash[Symbol, untyped]] results, ?cache_time: Integer?, ?is_personal: bool, ?next_offset: String?) -> void
+
+    # --- Payments ---
+    def send_invoice: (peer chat, title: String, description: String, payload: String, ?currency: String, amount: Integer, ?photo_url: String?) -> Types::Message?
+    def create_invoice_link: (title: String, description: String, payload: String, ?currency: String, amount: Integer) -> String
+    def answer_pre_checkout_query: (Integer query_id, ok: bool, ?error_message: String?) -> void
+    def refund_star_payment: (peer user_id, charge_id: String) -> bool
+    def get_star_transactions: (?offset: String, ?limit: Integer, ?inbound: bool, ?outbound: bool) -> Hash[Symbol, untyped]
+
+    # --- Sessions ---
+    def export_session: () -> String
+    def self.import_session: (String session_string, ?path: String) -> void
+    def save_session: () -> void
+
+    # --- Events ---
+    def on: (Class event_class, ?pattern: (Regexp | String)?, ?chats: (Array[peer] | peer)?) { (Events::Event) -> void } -> Events::Handler
+    def off: (Events::Handler handler) -> void
+    def run: () -> void
+    def stop: () -> void
+    def each_update: () { (Events::Event) -> void } -> void
+
+    # --- Conversations ---
+    def conversation: (peer chat, ?timeout: Integer, ?exclusive: bool) { (Conversation) -> void } -> Thread
+
+    # --- Raw TL ---
+    def invoke_raw: (String request_bytes) -> String
+
+    private
+
+    def safe_native: [T] () { () -> T } -> T
+    def peer_id: (untyped entity) -> String
+    def dispatch_event: (Events::Event event) -> void
+    def flush_album: (Array[Events::NewMessage]? events, Hash[Integer, Float] timers) -> void
+    def wrap_message: (Hash[Symbol, untyped] hash) -> Types::Message
+    def default_logger: () -> Logger
+    def build_buttons: (button_rows buttons) -> button_rows
+    def build_keys: (Array[Array[String | Hash[Symbol, untyped]]] keys) -> Array[Array[Hash[Symbol, untyped]]]
+  end
+end