Methods

Back to API documentation index

Go to the new description-version method index

$MadelineProto->logout();

$MadelineProto->phoneLogin($number);

$MadelineProto->completePhoneLogin($code);

$MadelineProto->complete2FALogin($password);

$MadelineProto->botLogin($token);

$MadelineProto->getDialogs();

$MadelineProto->getPwrChat($id);

$MadelineProto->getInfo($id);

$MadelineProto->getFullInfo($id);

$MadelineProto->getSelf();

$MadelineProto->requestCall($id);

$MadelineProto->requestSecretChat($id);

$MadelineProto->account->acceptAuthorization([bot_id: $long, scope: $string, public_key: $string, value_hashes: [$SecureValueHash], credentials: $SecureCredentialsEncrypted, ]) === $Bool

$MadelineProto->account->cancelPasswordEmail([]) === $Bool

$MadelineProto->account->changeAuthorizationSettings([confirmed: $Bool, hash: $long, encrypted_requests_disabled: $Bool, call_requests_disabled: $Bool, ]) === $Bool

$MadelineProto->account->changePhone([phone_number: $string, phone_code_hash: $string, phone_code: $string, ]) === $User

$MadelineProto->account->checkUsername([username: $string, ]) === $Bool

$MadelineProto->account->clearRecentEmojiStatuses([]) === $Bool

$MadelineProto->account->confirmPasswordEmail([code: $string, ]) === $Bool

$MadelineProto->account->confirmPhone([phone_code_hash: $string, phone_code: $string, ]) === $Bool

$MadelineProto->account->createBusinessChatLink([link: $InputBusinessChatLink, ]) === $BusinessChatLink

$MadelineProto->account->createTheme([slug: $string, title: $string, document: $InputDocument, settings: [$InputThemeSettings], ]) === $Theme

$MadelineProto->account->declinePasswordReset([]) === $Bool

$MadelineProto->account->deleteAccount([reason: $string, password: $InputCheckPasswordSRP, ]) === $Bool

$MadelineProto->account->deleteAutoSaveExceptions([]) === $Bool

$MadelineProto->account->deleteBusinessChatLink([slug: $string, ]) === $Bool

$MadelineProto->account->deleteSecureValue([types: [$SecureValueType], ]) === $Bool

$MadelineProto->account->disablePeerConnectedBot([peer: $InputPeer, ]) === $Bool

$MadelineProto->account->editBusinessChatLink([slug: $string, link: $InputBusinessChatLink, ]) === $BusinessChatLink

$MadelineProto->account->finishTakeoutSession([success: $Bool, ]) === $Bool

$MadelineProto->account->getAccountTTL([]) === $AccountDaysTTL

$MadelineProto->account->getAllSecureValues([]) === $Vector_of_SecureValue

$MadelineProto->account->getAuthorizationForm([bot_id: $long, scope: $string, public_key: $string, ]) === $account.AuthorizationForm

$MadelineProto->account->getAuthorizations([]) === $account.Authorizations

$MadelineProto->account->getAutoDownloadSettings([]) === $account.AutoDownloadSettings

$MadelineProto->account->getAutoSaveSettings([]) === $account.AutoSaveSettings

$MadelineProto->account->getBotBusinessConnection([connection_id: $string, ]) === $Updates

$MadelineProto->account->getBusinessChatLinks([]) === $account.BusinessChatLinks

$MadelineProto->account->getChannelDefaultEmojiStatuses([hash: $long, ]) === $account.EmojiStatuses

$MadelineProto->account->getChannelRestrictedStatusEmojis([hash: $long, ]) === $EmojiList

$MadelineProto->account->getChatThemes([hash: $long, ]) === $account.Themes

$MadelineProto->account->getConnectedBots([]) === $account.ConnectedBots

$MadelineProto->account->getContactSignUpNotification([]) === $Bool

$MadelineProto->account->getContentSettings([]) === $account.ContentSettings

$MadelineProto->account->getDefaultBackgroundEmojis([hash: $long, ]) === $EmojiList

$MadelineProto->account->getDefaultEmojiStatuses([hash: $long, ]) === $account.EmojiStatuses

$MadelineProto->account->getDefaultGroupPhotoEmojis([hash: $long, ]) === $EmojiList

$MadelineProto->account->getDefaultProfilePhotoEmojis([hash: $long, ]) === $EmojiList

$MadelineProto->account->getGlobalPrivacySettings([]) === $GlobalPrivacySettings

$MadelineProto->account->getMultiWallPapers([wallpapers: [$InputWallPaper], ]) === $Vector_of_WallPaper

$MadelineProto->account->getNotifyExceptions([compare_sound: $Bool, compare_stories: $Bool, peer: $InputNotifyPeer, ]) === $Updates

$MadelineProto->account->getNotifySettings([peer: $InputNotifyPeer, ]) === $PeerNotifySettings

$MadelineProto->account->getPassword([]) === $account.Password

$MadelineProto->account->getPasswordSettings([password: $InputCheckPasswordSRP, ]) === $account.PasswordSettings

$MadelineProto->account->getPrivacy([key: $InputPrivacyKey, ]) === $account.PrivacyRules

$MadelineProto->account->getReactionsNotifySettings([]) === $ReactionsNotifySettings

$MadelineProto->account->getRecentEmojiStatuses([hash: $long, ]) === $account.EmojiStatuses

$MadelineProto->account->getSavedRingtones([hash: $long, ]) === $account.SavedRingtones

$MadelineProto->account->getSecureValue([types: [$SecureValueType], ]) === $Vector_of_SecureValue

$MadelineProto->account->getTheme([format: $string, theme: $InputTheme, ]) === $Theme

$MadelineProto->account->getThemes([format: $string, hash: $long, ]) === $account.Themes

$MadelineProto->account->getTmpPassword([password: $InputCheckPasswordSRP, period: $int, ]) === $account.TmpPassword

$MadelineProto->account->getWallPaper([wallpaper: $InputWallPaper, ]) === $WallPaper

$MadelineProto->account->getWallPapers([hash: $long, ]) === $account.WallPapers

$MadelineProto->account->getWebAuthorizations([]) === $account.WebAuthorizations

$MadelineProto->account->initTakeoutSession([contacts: $Bool, message_users: $Bool, message_chats: $Bool, message_megagroups: $Bool, message_channels: $Bool, files: $Bool, file_max_size: $long, ]) === $account.Takeout

$MadelineProto->account->installTheme([dark: $Bool, theme: $InputTheme, format: $string, base_theme: $BaseTheme, ]) === $Bool

$MadelineProto->account->installWallPaper([wallpaper: $InputWallPaper, settings: $WallPaperSettings, ]) === $Bool

$MadelineProto->account->invalidateSignInCodes([codes: [$string], ]) === $Bool

$MadelineProto->account->registerDevice([no_muted: $Bool, token_type: $int, token: $string, app_sandbox: $Bool, secret: $bytes, other_uids: [$long], ]) === $Bool

$MadelineProto->account->reorderUsernames([order: [$string], ]) === $Bool

$MadelineProto->account->reportPeer([peer: $InputPeer, reason: $ReportReason, message: $string, ]) === $Bool

$MadelineProto->account->reportProfilePhoto([peer: $InputPeer, photo_id: $InputPhoto, reason: $ReportReason, message: $string, ]) === $Bool

$MadelineProto->account->resendPasswordEmail([]) === $Bool

$MadelineProto->account->resetAuthorization([hash: $long, ]) === $Bool

$MadelineProto->account->resetNotifySettings([]) === $Bool

$MadelineProto->account->resetPassword([]) === $account.ResetPasswordResult

$MadelineProto->account->resetWallPapers([]) === $Bool

$MadelineProto->account->resetWebAuthorization([hash: $long, ]) === $Bool

$MadelineProto->account->resetWebAuthorizations([]) === $Bool

$MadelineProto->account->resolveBusinessChatLink([slug: $string, ]) === $account.ResolvedBusinessChatLinks

$MadelineProto->account->saveAutoDownloadSettings([low: $Bool, high: $Bool, settings: $AutoDownloadSettings, ]) === $Bool

$MadelineProto->account->saveAutoSaveSettings([users: $Bool, chats: $Bool, broadcasts: $Bool, peer: $InputPeer, settings: $AutoSaveSettings, ]) === $Bool

$MadelineProto->account->saveRingtone([id: $InputDocument, unsave: $Bool, ]) === $account.SavedRingtone

$MadelineProto->account->saveSecureValue([value: $InputSecureValue, secure_secret_id: $long, ]) === $SecureValue

$MadelineProto->account->saveTheme([theme: $InputTheme, unsave: $Bool, ]) === $Bool

$MadelineProto->account->saveWallPaper([wallpaper: $InputWallPaper, unsave: $Bool, settings: $WallPaperSettings, ]) === $Bool

$MadelineProto->account->sendChangePhoneCode([phone_number: $string, settings: $CodeSettings, ]) === $auth.SentCode

$MadelineProto->account->sendConfirmPhoneCode([hash: $string, settings: $CodeSettings, ]) === $auth.SentCode

$MadelineProto->account->sendVerifyEmailCode([purpose: $EmailVerifyPurpose, email: $string, ]) === $account.SentEmailCode

$MadelineProto->account->sendVerifyPhoneCode([phone_number: $string, settings: $CodeSettings, ]) === $auth.SentCode

$MadelineProto->account->setAccountTTL([ttl: $AccountDaysTTL, ]) === $Bool

$MadelineProto->account->setAuthorizationTTL([authorization_ttl_days: $int, ]) === $Bool

$MadelineProto->account->setContactSignUpNotification([silent: $Bool, ]) === $Bool

$MadelineProto->account->setContentSettings([sensitive_enabled: $Bool, ]) === $Bool

$MadelineProto->account->setGlobalPrivacySettings([settings: $GlobalPrivacySettings, ]) === $GlobalPrivacySettings

$MadelineProto->account->setPrivacy([key: $InputPrivacyKey, rules: [$InputPrivacyRule], ]) === $account.PrivacyRules

$MadelineProto->account->setReactionsNotifySettings([settings: $ReactionsNotifySettings, ]) === $ReactionsNotifySettings

$MadelineProto->account->toggleConnectedBotPaused([peer: $InputPeer, paused: $Bool, ]) === $Bool

$MadelineProto->account->toggleSponsoredMessages([enabled: $Bool, ]) === $Bool

$MadelineProto->account->toggleUsername([username: $string, active: $Bool, ]) === $Bool

$MadelineProto->account->unregisterDevice([token_type: $int, token: $string, other_uids: [$long], ]) === $Bool

$MadelineProto->account->updateBirthday([birthday: $Birthday, ]) === $Bool

$MadelineProto->account->updateBusinessAwayMessage([message: $InputBusinessAwayMessage, ]) === $Bool

$MadelineProto->account->updateBusinessGreetingMessage([message: $InputBusinessGreetingMessage, ]) === $Bool

$MadelineProto->account->updateBusinessIntro([intro: $InputBusinessIntro, ]) === $Bool

$MadelineProto->account->updateBusinessLocation([geo_point: $InputGeoPoint, address: $string, ]) === $Bool

$MadelineProto->account->updateBusinessWorkHours([business_work_hours: $BusinessWorkHours, ]) === $Bool

$MadelineProto->account->updateColor([for_profile: $Bool, color: $int, background_emoji_id: $long, ]) === $Bool

$MadelineProto->account->updateConnectedBot([can_reply: $Bool, deleted: $Bool, bot: $InputUser, recipients: $InputBusinessBotRecipients, ]) === $Updates

$MadelineProto->account->updateDeviceLocked([period: $int, ]) === $Bool

$MadelineProto->account->updateEmojiStatus([emoji_status: $EmojiStatus, ]) === $Bool

$MadelineProto->account->updateNotifySettings([peer: $InputNotifyPeer, settings: $InputPeerNotifySettings, ]) === $Bool

$MadelineProto->account->updatePasswordSettings([password: $InputCheckPasswordSRP, new_settings: $account.PasswordInputSettings, ]) === $Bool

$MadelineProto->account->updatePersonalChannel([channel: $InputChannel, ]) === $Bool

$MadelineProto->account->updateProfile([first_name: $string, last_name: $string, about: $string, ]) === $User

$MadelineProto->account->updateStatus([offline: $Bool, ]) === $Bool

$MadelineProto->account->updateTheme([format: $string, theme: $InputTheme, slug: $string, title: $string, document: $InputDocument, settings: [$InputThemeSettings], ]) === $Theme

$MadelineProto->account->updateUsername([username: $string, ]) === $User

$MadelineProto->account->uploadRingtone([file: $InputFile, file_name: $string, mime_type: $string, ]) === $Document

$MadelineProto->account->uploadTheme([file: $InputFile, thumb: $InputFile, file_name: $string, mime_type: $string, ]) === $Document

$MadelineProto->account->uploadWallPaper([for_chat: $Bool, file: $InputFile, mime_type: $string, settings: $WallPaperSettings, ]) === $WallPaper

$MadelineProto->account->verifyEmail([purpose: $EmailVerifyPurpose, verification: $EmailVerification, ]) === $account.EmailVerified

$MadelineProto->account->verifyPhone([phone_number: $string, phone_code_hash: $string, phone_code: $string, ]) === $Bool

$MadelineProto->auth->acceptLoginToken([token: $bytes, ]) === $Authorization

$MadelineProto->auth->bindTempAuthKey([perm_auth_key_id: $long, nonce: $long, expires_at: $int, encrypted_message: $bytes, ]) === $Bool

$MadelineProto->auth->cancelCode([phone_number: $string, phone_code_hash: $string, ]) === $Bool

$MadelineProto->auth->checkPassword([password: $InputCheckPasswordSRP, ]) === $auth.Authorization

$MadelineProto->auth->checkRecoveryPassword([code: $string, ]) === $Bool

$MadelineProto->auth->dropTempAuthKeys([except_auth_keys: [$long], ]) === $Bool

$MadelineProto->auth->exportAuthorization([dc_id: $int, ]) === $auth.ExportedAuthorization

$MadelineProto->auth->exportLoginToken([api_id: $int, api_hash: $string, except_ids: [$long], ]) === $auth.LoginToken

$MadelineProto->auth->importAuthorization([id: $long, bytes: $bytes, ]) === $auth.Authorization

$MadelineProto->auth->importBotAuthorization([api_id: $int, api_hash: $string, bot_auth_token: $string, ]) === $auth.Authorization

$MadelineProto->auth->importLoginToken([token: $bytes, ]) === $auth.LoginToken

$MadelineProto->auth->importWebTokenAuthorization([api_id: $int, api_hash: $string, web_auth_token: $string, ]) === $auth.Authorization

$MadelineProto->auth->logOut([]) === $auth.LoggedOut

$MadelineProto->auth->recoverPassword([code: $string, new_settings: $account.PasswordInputSettings, ]) === $auth.Authorization

$MadelineProto->auth->reportMissingCode([phone_number: $string, phone_code_hash: $string, mnc: $string, ]) === $Bool

$MadelineProto->auth->requestFirebaseSms([phone_number: $string, phone_code_hash: $string, safety_net_token: $string, play_integrity_token: $string, ios_push_secret: $string, ]) === $Bool

$MadelineProto->auth->requestPasswordRecovery([]) === $auth.PasswordRecovery

$MadelineProto->auth->resendCode([phone_number: $string, phone_code_hash: $string, reason: $string, ]) === $auth.SentCode

$MadelineProto->auth->resetAuthorizations([]) === $Bool

$MadelineProto->auth->resetLoginEmail([phone_number: $string, phone_code_hash: $string, ]) === $auth.SentCode

$MadelineProto->auth->sendCode([phone_number: $string, api_id: $int, api_hash: $string, settings: $CodeSettings, ]) === $auth.SentCode

$MadelineProto->auth->signIn([phone_number: $string, phone_code_hash: $string, phone_code: $string, email_verification: $EmailVerification, ]) === $auth.Authorization

$MadelineProto->auth->signUp([no_joined_notifications: $Bool, phone_number: $string, phone_code_hash: $string, first_name: $string, last_name: $string, ]) === $auth.Authorization

$MadelineProto->bots->addPreviewMedia([bot: $InputUser, lang_code: $string, media: $InputMedia, ]) === $BotPreviewMedia

$MadelineProto->bots->allowSendMessage([bot: $InputUser, ]) === $Updates

$MadelineProto->bots->answerWebhookJSONQuery([query_id: $long, data: $DataJSON, ]) === $Bool

$MadelineProto->bots->canSendMessage([bot: $InputUser, ]) === $Bool

$MadelineProto->bots->checkDownloadFileParams([bot: $InputUser, file_name: $string, url: $string, ]) === $Bool

$MadelineProto->bots->deletePreviewMedia([bot: $InputUser, lang_code: $string, media: [$InputMedia], ]) === $Bool

$MadelineProto->bots->editPreviewMedia([bot: $InputUser, lang_code: $string, media: $InputMedia, new_media: $InputMedia, ]) === $BotPreviewMedia

$MadelineProto->bots->getAdminedBots([]) === $Vector_of_User

$MadelineProto->bots->getBotCommands([scope: $BotCommandScope, lang_code: $string, ]) === $Vector_of_BotCommand

$MadelineProto->bots->getBotInfo([bot: $InputUser, lang_code: $string, ]) === $bots.BotInfo

$MadelineProto->bots->getBotMenuButton([user_id: $InputUser, ]) === $BotMenuButton

$MadelineProto->bots->getPopularAppBots([offset: $string, limit: $int, ]) === $bots.PopularAppBots

$MadelineProto->bots->getPreviewInfo([bot: $InputUser, lang_code: $string, ]) === $bots.PreviewInfo

$MadelineProto->bots->getPreviewMedias([bot: $InputUser, ]) === $Vector_of_BotPreviewMedia

$MadelineProto->bots->invokeWebViewCustomMethod([bot: $InputUser, custom_method: $string, params: $DataJSON, ]) === $DataJSON

$MadelineProto->bots->reorderPreviewMedias([bot: $InputUser, lang_code: $string, order: [$InputMedia], ]) === $Bool

$MadelineProto->bots->reorderUsernames([bot: $InputUser, order: [$string], ]) === $Bool

$MadelineProto->bots->resetBotCommands([scope: $BotCommandScope, lang_code: $string, ]) === $Bool

$MadelineProto->bots->sendCustomRequest([custom_method: $string, params: $DataJSON, ]) === $DataJSON

$MadelineProto->bots->setBotBroadcastDefaultAdminRights([admin_rights: $ChatAdminRights, ]) === $Bool

$MadelineProto->bots->setBotCommands([scope: $BotCommandScope, lang_code: $string, commands: [$BotCommand], ]) === $Bool

$MadelineProto->bots->setBotGroupDefaultAdminRights([admin_rights: $ChatAdminRights, ]) === $Bool

$MadelineProto->bots->setBotInfo([bot: $InputUser, lang_code: $string, name: $string, about: $string, description: $string, ]) === $Bool

$MadelineProto->bots->setBotMenuButton([user_id: $InputUser, button: $BotMenuButton, ]) === $Bool

$MadelineProto->bots->toggleUserEmojiStatusPermission([bot: $InputUser, enabled: $Bool, ]) === $Bool

$MadelineProto->bots->toggleUsername([bot: $InputUser, username: $string, active: $Bool, ]) === $Bool

$MadelineProto->bots->updateStarRefProgram([bot: $InputUser, commission_permille: $int, duration_months: $int, ]) === $StarRefProgram

$MadelineProto->bots->updateUserEmojiStatus([user_id: $InputUser, emoji_status: $EmojiStatus, ]) === $Bool

$MadelineProto->channels->checkUsername([channel: $InputChannel, username: $string, ]) === $Bool

$MadelineProto->channels->convertToGigagroup([channel: $InputChannel, ]) === $Updates

$MadelineProto->channels->createChannel([broadcast: $Bool, megagroup: $Bool, for_import: $Bool, forum: $Bool, title: $string, about: $string, geo_point: $InputGeoPoint, address: $string, ttl_period: $int, ]) === $Updates

$MadelineProto->channels->createForumTopic([channel: $InputChannel, title: $string, icon_color: $int, icon_emoji_id: $long, send_as: $InputPeer, ]) === $Updates

$MadelineProto->channels->deactivateAllUsernames([channel: $InputChannel, ]) === $Bool

$MadelineProto->channels->deleteChannel([channel: $InputChannel, ]) === $Updates

$MadelineProto->channels->deleteHistory([for_everyone: $Bool, channel: $InputChannel, max_id: $int, ]) === $Updates

$MadelineProto->channels->deleteMessages([channel: $InputChannel, id: [$int], ]) === $messages.AffectedMessages

$MadelineProto->channels->deleteParticipantHistory([channel: $InputChannel, participant: $InputPeer, ]) === $messages.AffectedHistory

$MadelineProto->channels->deleteTopicHistory([channel: $InputChannel, top_msg_id: $int, ]) === $messages.AffectedHistory

$MadelineProto->channels->editAdmin([channel: $InputChannel, user_id: $InputUser, admin_rights: $ChatAdminRights, rank: $string, ]) === $Updates

$MadelineProto->channels->editBanned([channel: $InputChannel, participant: $InputPeer, banned_rights: $ChatBannedRights, ]) === $Updates

$MadelineProto->channels->editCreator([channel: $InputChannel, user_id: $InputUser, password: $InputCheckPasswordSRP, ]) === $Updates

$MadelineProto->channels->editForumTopic([channel: $InputChannel, topic_id: $int, title: $string, icon_emoji_id: $long, closed: $Bool, hidden: $Bool, ]) === $Updates

$MadelineProto->channels->editLocation([channel: $InputChannel, geo_point: $InputGeoPoint, address: $string, ]) === $Bool

$MadelineProto->channels->editPhoto([channel: $InputChannel, photo: $InputChatPhoto, ]) === $Updates

$MadelineProto->channels->editTitle([channel: $InputChannel, title: $string, ]) === $Updates

$MadelineProto->channels->exportMessageLink([grouped: $Bool, thread: $Bool, channel: $InputChannel, id: $int, ]) === $ExportedMessageLink

$MadelineProto->channels->getAdminLog([channel: $InputChannel, q: $string, events_filter: $ChannelAdminLogEventsFilter, admins: [$InputUser], max_id: $long, min_id: $long, limit: $int, ]) === $channels.AdminLogResults

$MadelineProto->channels->getAdminedPublicChannels([by_location: $Bool, check_limit: $Bool, for_personal: $Bool, ]) === $messages.Chats

$MadelineProto->channels->getChannelRecommendations([channel: $InputChannel, ]) === $messages.Chats

$MadelineProto->channels->getChannels([id: [$InputChannel], ]) === $messages.Chats

$MadelineProto->channels->getForumTopics([channel: $InputChannel, q: $string, offset_date: $int, offset_id: $int, offset_topic: $int, limit: $int, ]) === $messages.ForumTopics

$MadelineProto->channels->getForumTopicsByID([channel: $InputChannel, topics: [$int], ]) === $messages.ForumTopics

$MadelineProto->channels->getFullChannel([channel: $InputChannel, ]) === $messages.ChatFull

$MadelineProto->channels->getGroupsForDiscussion([]) === $messages.Chats

$MadelineProto->channels->getInactiveChannels([]) === $messages.InactiveChats

$MadelineProto->channels->getLeftChannels([offset: $int, ]) === $messages.Chats

$MadelineProto->channels->getMessages([channel: $InputChannel, id: [$InputMessage], ]) === $messages.Messages

$MadelineProto->channels->getParticipant([channel: $InputChannel, participant: $InputPeer, ]) === $channels.ChannelParticipant

$MadelineProto->channels->getParticipants([channel: $InputChannel, filter: $ChannelParticipantsFilter, offset: $int, limit: $int, hash: $long, ]) === $channels.ChannelParticipants

$MadelineProto->channels->getSendAs([peer: $InputPeer, ]) === $channels.SendAsPeers

$MadelineProto->channels->inviteToChannel([channel: $InputChannel, users: [$InputUser], ]) === $messages.InvitedUsers

$MadelineProto->channels->joinChannel([channel: $InputChannel, ]) === $Updates

$MadelineProto->channels->leaveChannel([channel: $InputChannel, ]) === $Updates

$MadelineProto->channels->readHistory([channel: $InputChannel, max_id: $int, ]) === $Bool

$MadelineProto->channels->readMessageContents([channel: $InputChannel, id: [$int], ]) === $Bool

$MadelineProto->channels->reorderPinnedForumTopics([force: $Bool, channel: $InputChannel, order: [$int], ]) === $Updates

$MadelineProto->channels->reorderUsernames([channel: $InputChannel, order: [$string], ]) === $Bool

$MadelineProto->channels->reportAntiSpamFalsePositive([channel: $InputChannel, msg_id: $int, ]) === $Bool

$MadelineProto->channels->reportSpam([channel: $InputChannel, participant: $InputPeer, id: [$int], ]) === $Bool

$MadelineProto->channels->restrictSponsoredMessages([channel: $InputChannel, restricted: $Bool, ]) === $Updates

$MadelineProto->channels->searchPosts([hashtag: $string, offset_rate: $int, offset_peer: $InputPeer, offset_id: $int, limit: $int, ]) === $messages.Messages

$MadelineProto->channels->setBoostsToUnblockRestrictions([channel: $InputChannel, boosts: $int, ]) === $Updates

$MadelineProto->channels->setDiscussionGroup([broadcast: $InputChannel, group: $InputChannel, ]) === $Bool

$MadelineProto->channels->setEmojiStickers([channel: $InputChannel, stickerset: $InputStickerSet, ]) === $Bool

$MadelineProto->channels->setStickers([channel: $InputChannel, stickerset: $InputStickerSet, ]) === $Bool

$MadelineProto->channels->toggleAntiSpam([channel: $InputChannel, enabled: $Bool, ]) === $Updates

$MadelineProto->channels->toggleForum([channel: $InputChannel, enabled: $Bool, ]) === $Updates

$MadelineProto->channels->toggleJoinRequest([channel: $InputChannel, enabled: $Bool, ]) === $Updates

$MadelineProto->channels->toggleJoinToSend([channel: $InputChannel, enabled: $Bool, ]) === $Updates

$MadelineProto->channels->toggleParticipantsHidden([channel: $InputChannel, enabled: $Bool, ]) === $Updates

$MadelineProto->channels->togglePreHistoryHidden([channel: $InputChannel, enabled: $Bool, ]) === $Updates

$MadelineProto->channels->toggleSignatures([signatures_enabled: $Bool, profiles_enabled: $Bool, channel: $InputChannel, ]) === $Updates

$MadelineProto->channels->toggleSlowMode([channel: $InputChannel, seconds: $int, ]) === $Updates

$MadelineProto->channels->toggleUsername([channel: $InputChannel, username: $string, active: $Bool, ]) === $Bool

$MadelineProto->channels->toggleViewForumAsMessages([channel: $InputChannel, enabled: $Bool, ]) === $Updates

$MadelineProto->channels->updateColor([for_profile: $Bool, channel: $InputChannel, color: $int, background_emoji_id: $long, ]) === $Updates

$MadelineProto->channels->updateEmojiStatus([channel: $InputChannel, emoji_status: $EmojiStatus, ]) === $Updates

$MadelineProto->channels->updatePinnedForumTopic([channel: $InputChannel, topic_id: $int, pinned: $Bool, ]) === $Updates

$MadelineProto->channels->updateUsername([channel: $InputChannel, username: $string, ]) === $Bool

$MadelineProto->chatlists->checkChatlistInvite([slug: $string, ]) === $chatlists.ChatlistInvite

$MadelineProto->chatlists->deleteExportedInvite([chatlist: $InputChatlist, slug: $string, ]) === $Bool

$MadelineProto->chatlists->editExportedInvite([chatlist: $InputChatlist, slug: $string, title: $string, peers: [$InputPeer], ]) === $ExportedChatlistInvite

$MadelineProto->chatlists->exportChatlistInvite([chatlist: $InputChatlist, title: $string, peers: [$InputPeer], ]) === $chatlists.ExportedChatlistInvite

$MadelineProto->chatlists->getChatlistUpdates([chatlist: $InputChatlist, ]) === $chatlists.ChatlistUpdates

$MadelineProto->chatlists->getExportedInvites([chatlist: $InputChatlist, ]) === $chatlists.ExportedInvites

$MadelineProto->chatlists->getLeaveChatlistSuggestions([chatlist: $InputChatlist, ]) === $Vector_of_Peer

$MadelineProto->chatlists->hideChatlistUpdates([chatlist: $InputChatlist, ]) === $Bool

$MadelineProto->chatlists->joinChatlistInvite([slug: $string, peers: [$InputPeer], ]) === $Updates

$MadelineProto->chatlists->joinChatlistUpdates([chatlist: $InputChatlist, peers: [$InputPeer], ]) === $Updates

$MadelineProto->chatlists->leaveChatlist([chatlist: $InputChatlist, peers: [$InputPeer], ]) === $Updates

$MadelineProto->contacts->acceptContact([id: $InputUser, ]) === $Updates

$MadelineProto->contacts->addContact([add_phone_privacy_exception: $Bool, id: $InputUser, first_name: $string, last_name: $string, phone: $string, ]) === $Updates

$MadelineProto->contacts->block([my_stories_from: $Bool, id: $InputPeer, ]) === $Bool

$MadelineProto->contacts->blockFromReplies([delete_message: $Bool, delete_history: $Bool, report_spam: $Bool, msg_id: $int, ]) === $Updates

$MadelineProto->contacts->deleteByPhones([phones: [$string], ]) === $Bool

$MadelineProto->contacts->deleteContacts([id: [$InputUser], ]) === $Updates

$MadelineProto->contacts->editCloseFriends([id: [$long], ]) === $Bool

$MadelineProto->contacts->exportContactToken([]) === $ExportedContactToken

$MadelineProto->contacts->getBirthdays([]) === $contacts.ContactBirthdays

$MadelineProto->contacts->getBlocked([my_stories_from: $Bool, offset: $int, limit: $int, ]) === $contacts.Blocked

$MadelineProto->contacts->getContactIDs([hash: $long, ]) === $Vector_of_int

$MadelineProto->contacts->getContacts([hash: $long, ]) === $contacts.Contacts

$MadelineProto->contacts->getLocated([background: $Bool, geo_point: $InputGeoPoint, self_expires: $int, ]) === $Updates

$MadelineProto->contacts->getSaved([]) === $Vector_of_SavedContact

$MadelineProto->contacts->getStatuses([]) === $Vector_of_ContactStatus

$MadelineProto->contacts->getTopPeers([correspondents: $Bool, bots_pm: $Bool, bots_inline: $Bool, phone_calls: $Bool, forward_users: $Bool, forward_chats: $Bool, groups: $Bool, channels: $Bool, bots_app: $Bool, offset: $int, limit: $int, hash: $long, ]) === $contacts.TopPeers

$MadelineProto->contacts->importContactToken([token: $string, ]) === $User

$MadelineProto->contacts->importContacts([contacts: [$InputContact], ]) === $contacts.ImportedContacts

$MadelineProto->contacts->resetSaved([]) === $Bool

$MadelineProto->contacts->resetTopPeerRating([category: $TopPeerCategory, peer: $InputPeer, ]) === $Bool

$MadelineProto->contacts->resolvePhone([phone: $string, ]) === $contacts.ResolvedPeer

$MadelineProto->contacts->resolveUsername([username: $string, referer: $string, ]) === $contacts.ResolvedPeer

$MadelineProto->contacts->search([q: $string, limit: $int, ]) === $contacts.Found

$MadelineProto->contacts->setBlocked([my_stories_from: $Bool, id: [$InputPeer], limit: $int, ]) === $Bool

$MadelineProto->contacts->toggleTopPeers([enabled: $Bool, ]) === $Bool

$MadelineProto->contacts->unblock([my_stories_from: $Bool, id: $InputPeer, ]) === $Bool

$MadelineProto->folders->editPeerFolders([folder_peers: [$InputFolderPeer], ]) === $Updates

$MadelineProto->fragment->getCollectibleInfo([collectible: $InputCollectible, ]) === $fragment.CollectibleInfo

$MadelineProto->help->acceptTermsOfService([id: $DataJSON, ]) === $Bool

$MadelineProto->help->dismissSuggestion([peer: $InputPeer, suggestion: $string, ]) === $Bool

$MadelineProto->help->editUserInfo([user_id: $InputUser, message: $string, entities: [$MessageEntity], ]) === $help.UserInfo

$MadelineProto->help->getAppConfig([hash: $int, ]) === $help.AppConfig

$MadelineProto->help->getAppUpdate([source: $string, ]) === $help.AppUpdate

$MadelineProto->help->getCdnConfig([]) === $CdnConfig

$MadelineProto->help->getConfig([]) === $Config

$MadelineProto->help->getCountriesList([lang_code: $string, hash: $int, ]) === $help.CountriesList

$MadelineProto->help->getDeepLinkInfo([path: $string, ]) === $help.DeepLinkInfo

$MadelineProto->help->getInviteText([]) === $help.InviteText

$MadelineProto->help->getNearestDc([]) === $NearestDc

$MadelineProto->help->getPassportConfig([hash: $int, ]) === $help.PassportConfig

$MadelineProto->help->getPeerColors([hash: $int, ]) === $help.PeerColors

$MadelineProto->help->getPeerProfileColors([hash: $int, ]) === $help.PeerColors

$MadelineProto->help->getPremiumPromo([]) === $help.PremiumPromo

$MadelineProto->help->getPromoData([]) === $help.PromoData

$MadelineProto->help->getRecentMeUrls([referer: $string, ]) === $help.RecentMeUrls

$MadelineProto->help->getSupport([]) === $help.Support

$MadelineProto->help->getSupportName([]) === $help.SupportName

$MadelineProto->help->getTermsOfServiceUpdate([]) === $help.TermsOfServiceUpdate

$MadelineProto->help->getTimezonesList([hash: $int, ]) === $help.TimezonesList

$MadelineProto->help->getUserInfo([user_id: $InputUser, ]) === $help.UserInfo

$MadelineProto->help->hidePromoData([peer: $InputPeer, ]) === $Bool

$MadelineProto->help->saveAppLog([events: [$InputAppEvent], ]) === $Bool

$MadelineProto->help->setBotUpdatesStatus([pending_updates_count: $int, message: $string, ]) === $Bool

$MadelineProto->initConnection([api_id: $int, device_model: $string, system_version: $string, app_version: $string, system_lang_code: $string, lang_pack: $string, lang_code: $string, proxy: $InputClientProxy, params: $JSONValue, query: $!X, ]) === $X

$MadelineProto->invokeAfterMsg([msg_id: $long, query: $!X, ]) === $X

$MadelineProto->invokeAfterMsgs([msg_ids: [$long], query: $!X, ]) === $X

$MadelineProto->invokeWithApnsSecret([nonce: $string, secret: $string, query: $!X, ]) === $X

$MadelineProto->invokeWithBusinessConnection([connection_id: $string, query: $!X, ]) === $X

$MadelineProto->invokeWithGooglePlayIntegrity([nonce: $string, token: $string, query: $!X, ]) === $X

$MadelineProto->invokeWithLayer([layer: $int, query: $!X, ]) === $X

$MadelineProto->invokeWithMessagesRange([range: $MessageRange, query: $!X, ]) === $X

$MadelineProto->invokeWithTakeout([takeout_id: $long, query: $!X, ]) === $X

$MadelineProto->invokeWithoutUpdates([query: $!X, ]) === $X

$MadelineProto->langpack->getDifference([lang_pack: $string, lang_code: $string, from_version: $int, ]) === $LangPackDifference

$MadelineProto->langpack->getLangPack([lang_pack: $string, lang_code: $string, ]) === $LangPackDifference

$MadelineProto->langpack->getLanguage([lang_pack: $string, lang_code: $string, ]) === $LangPackLanguage

$MadelineProto->langpack->getLanguages([lang_pack: $string, ]) === $Vector_of_LangPackLanguage

$MadelineProto->langpack->getStrings([lang_pack: $string, lang_code: $string, keys: [$string], ]) === $Vector_of_LangPackString

$MadelineProto->messages->acceptEncryption([peer: $InputEncryptedChat, g_b: $bytes, key_fingerprint: $strlong, ]) === $EncryptedChat

$MadelineProto->messages->acceptUrlAuth([write_allowed: $Bool, peer: $InputPeer, msg_id: $int, button_id: $int, url: $string, ]) === $UrlAuthResult

$MadelineProto->messages->addChatUser([chat_id: $InputPeer, user_id: $InputUser, fwd_limit: $int, ]) === $messages.InvitedUsers

$MadelineProto->messages->checkChatInvite([hash: $string, ]) === $ChatInvite

$MadelineProto->messages->checkHistoryImport([import_head: $string, ]) === $messages.HistoryImportParsed

$MadelineProto->messages->checkHistoryImportPeer([peer: $InputPeer, ]) === $messages.CheckedHistoryImportPeer

$MadelineProto->messages->checkQuickReplyShortcut([shortcut: $string, ]) === $Bool

$MadelineProto->messages->clearAllDrafts([]) === $Bool

$MadelineProto->messages->clearRecentReactions([]) === $Bool

$MadelineProto->messages->clearRecentStickers([attached: $Bool, ]) === $Bool

$MadelineProto->messages->clickSponsoredMessage([media: $Bool, fullscreen: $Bool, peer: $InputPeer, random_id: $bytes, ]) === $Bool

$MadelineProto->messages->createChat([users: [$InputUser], title: $string, ttl_period: $int, ]) === $messages.InvitedUsers

$MadelineProto->messages->deleteChat([chat_id: $InputPeer, ]) === $Bool

$MadelineProto->messages->deleteChatUser([revoke_history: $Bool, chat_id: $InputPeer, user_id: $InputUser, ]) === $Updates

$MadelineProto->messages->deleteExportedChatInvite([peer: $InputPeer, link: $string, ]) === $Bool

$MadelineProto->messages->deleteFactCheck([peer: $InputPeer, msg_id: $int, ]) === $Updates

$MadelineProto->messages->deleteHistory([just_clear: $Bool, revoke: $Bool, peer: $InputPeer, max_id: $int, min_date: $int, max_date: $int, ]) === $messages.AffectedHistory

$MadelineProto->messages->deleteMessages([revoke: $Bool, id: [$int], ]) === $messages.AffectedMessages

$MadelineProto->messages->deletePhoneCallHistory([revoke: $Bool, ]) === $messages.AffectedFoundMessages

$MadelineProto->messages->deleteQuickReplyMessages([shortcut_id: $int, id: [$int], ]) === $Updates

$MadelineProto->messages->deleteQuickReplyShortcut([shortcut_id: $int, ]) === $Bool

$MadelineProto->messages->deleteRevokedExportedChatInvites([peer: $InputPeer, admin_id: $InputUser, ]) === $Bool

$MadelineProto->messages->deleteSavedHistory([peer: $InputPeer, max_id: $int, min_date: $int, max_date: $int, ]) === $messages.AffectedHistory

$MadelineProto->messages->deleteScheduledMessages([peer: $InputPeer, id: [$int], ]) === $Updates

$MadelineProto->messages->discardEncryption([delete_history: $Bool, chat_id: $int, ]) === $Bool

$MadelineProto->messages->editChatAbout([peer: $InputPeer, about: $string, ]) === $Bool

$MadelineProto->messages->editChatAdmin([chat_id: $InputPeer, user_id: $InputUser, is_admin: $Bool, ]) === $Bool

$MadelineProto->messages->editChatDefaultBannedRights([peer: $InputPeer, banned_rights: $ChatBannedRights, ]) === $Updates

$MadelineProto->messages->editChatPhoto([chat_id: $InputPeer, photo: $InputChatPhoto, ]) === $Updates

$MadelineProto->messages->editChatTitle([chat_id: $InputPeer, title: $string, ]) === $Updates

$MadelineProto->messages->editExportedChatInvite([revoked: $Bool, peer: $InputPeer, link: $string, expire_date: $int, usage_limit: $int, request_needed: $Bool, title: $string, ]) === $messages.ExportedChatInvite

$MadelineProto->messages->editFactCheck([peer: $InputPeer, msg_id: $int, text: $TextWithEntities, ]) === $Updates

$MadelineProto->messages->editInlineBotMessage([no_webpage: $Bool, invert_media: $Bool, id: $InputBotInlineMessageID, message: $string, media: $InputMedia, reply_markup: $ReplyMarkup, entities: [$MessageEntity], ]) === $Bool

$MadelineProto->messages->editMessage([no_webpage: $Bool, invert_media: $Bool, peer: $InputPeer, id: $int, message: $string, media: $InputMedia, reply_markup: $ReplyMarkup, entities: [$MessageEntity], schedule_date: $int, quick_reply_shortcut_id: $int, ]) === $Updates

$MadelineProto->messages->editQuickReplyShortcut([shortcut_id: $int, shortcut: $string, ]) === $Bool

$MadelineProto->messages->exportChatInvite([legacy_revoke_permanent: $Bool, request_needed: $Bool, peer: $InputPeer, expire_date: $int, usage_limit: $int, title: $string, subscription_pricing: $StarsSubscriptionPricing, ]) === $ExportedChatInvite

$MadelineProto->messages->faveSticker([id: $InputDocument, unfave: $Bool, ]) === $Bool

$MadelineProto->messages->forwardMessages([silent: $Bool, background: $Bool, with_my_score: $Bool, drop_author: $Bool, drop_media_captions: $Bool, noforwards: $Bool, allow_paid_floodskip: $Bool, from_peer: $InputPeer, id: [$int], to_peer: $InputPeer, top_msg_id: $int, schedule_date: $int, send_as: $InputPeer, quick_reply_shortcut: $InputQuickReplyShortcut, ]) === $Updates

$MadelineProto->messages->getAdminsWithInvites([peer: $InputPeer, ]) === $messages.ChatAdminsWithInvites

$MadelineProto->messages->getAllDrafts([]) === $Updates

$MadelineProto->messages->getAllStickers([hash: $long, ]) === $messages.AllStickers

$MadelineProto->messages->getArchivedStickers([masks: $Bool, emojis: $Bool, offset_id: $long, limit: $int, ]) === $messages.ArchivedStickers

$MadelineProto->messages->getAttachMenuBot([bot: $InputUser, ]) === $AttachMenuBotsBot

$MadelineProto->messages->getAttachMenuBots([hash: $long, ]) === $AttachMenuBots

$MadelineProto->messages->getAttachedStickers([media: $InputStickeredMedia, ]) === $Vector_of_StickerSetCovered

$MadelineProto->messages->getAvailableEffects([hash: $int, ]) === $messages.AvailableEffects

$MadelineProto->messages->getAvailableReactions([hash: $int, ]) === $messages.AvailableReactions

$MadelineProto->messages->getBotApp([app: $InputBotApp, hash: $long, ]) === $messages.BotApp

$MadelineProto->messages->getBotCallbackAnswer([game: $Bool, peer: $InputPeer, msg_id: $int, data: $bytes, password: $InputCheckPasswordSRP, ]) === $messages.BotCallbackAnswer

$MadelineProto->messages->getChatInviteImporters([requested: $Bool, subscription_expired: $Bool, peer: $InputPeer, link: $string, q: $string, offset_date: $int, offset_user: $InputUser, limit: $int, ]) === $messages.ChatInviteImporters

$MadelineProto->messages->getChats([id: [$long], ]) === $messages.Chats

$MadelineProto->messages->getCommonChats([user_id: $InputUser, max_id: $long, limit: $int, ]) === $messages.Chats

$MadelineProto->messages->getCustomEmojiDocuments([document_id: [$long], ]) === $Vector_of_Document

$MadelineProto->messages->getDefaultHistoryTTL([]) === $DefaultHistoryTTL

$MadelineProto->messages->getDefaultTagReactions([hash: $long, ]) === $messages.Reactions

$MadelineProto->messages->getDhConfig([version: $int, random_length: $int, ]) === $messages.DhConfig

$MadelineProto->messages->getDialogFilters([]) === $messages.DialogFilters

$MadelineProto->messages->getDialogUnreadMarks([]) === $Vector_of_DialogPeer

$MadelineProto->messages->getDialogs([exclude_pinned: $Bool, folder_id: $int, offset_date: $int, offset_id: $int, offset_peer: $InputPeer, limit: $int, hash: $long, ]) === $messages.Dialogs

$MadelineProto->messages->getDiscussionMessage([peer: $InputPeer, msg_id: $int, ]) === $messages.DiscussionMessage

$MadelineProto->messages->getDocumentByHash([sha256: $bytes, size: $long, mime_type: $string, ]) === $Document

$MadelineProto->messages->getEmojiGroups([hash: $int, ]) === $messages.EmojiGroups

$MadelineProto->messages->getEmojiKeywords([lang_code: $string, ]) === $EmojiKeywordsDifference

$MadelineProto->messages->getEmojiKeywordsDifference([lang_code: $string, from_version: $int, ]) === $EmojiKeywordsDifference

$MadelineProto->messages->getEmojiKeywordsLanguages([lang_codes: [$string], ]) === $Vector_of_EmojiLanguage

$MadelineProto->messages->getEmojiProfilePhotoGroups([hash: $int, ]) === $messages.EmojiGroups

$MadelineProto->messages->getEmojiStatusGroups([hash: $int, ]) === $messages.EmojiGroups

$MadelineProto->messages->getEmojiStickerGroups([hash: $int, ]) === $messages.EmojiGroups

$MadelineProto->messages->getEmojiStickers([hash: $long, ]) === $messages.AllStickers

$MadelineProto->messages->getEmojiURL([lang_code: $string, ]) === $EmojiURL

$MadelineProto->messages->getExportedChatInvite([peer: $InputPeer, link: $string, ]) === $messages.ExportedChatInvite

$MadelineProto->messages->getExportedChatInvites([revoked: $Bool, peer: $InputPeer, admin_id: $InputUser, offset_date: $int, offset_link: $string, limit: $int, ]) === $messages.ExportedChatInvites

$MadelineProto->messages->getExtendedMedia([peer: $InputPeer, id: [$int], ]) === $Updates

$MadelineProto->messages->getFactCheck([peer: $InputPeer, msg_id: [$int], ]) === $Vector_of_FactCheck

$MadelineProto->messages->getFavedStickers([hash: $long, ]) === $messages.FavedStickers

$MadelineProto->messages->getFeaturedEmojiStickers([hash: $long, ]) === $messages.FeaturedStickers

$MadelineProto->messages->getFeaturedStickers([hash: $long, ]) === $messages.FeaturedStickers

$MadelineProto->messages->getFullChat([chat_id: $InputPeer, ]) === $messages.ChatFull

$MadelineProto->messages->getGameHighScores([peer: $InputPeer, id: $int, user_id: $InputUser, ]) === $messages.HighScores

$MadelineProto->messages->getHistory([peer: $InputPeer, offset_id: $int, offset_date: $int, add_offset: $int, limit: $int, max_id: $int, min_id: $int, hash: $long, ]) === $messages.Messages

$MadelineProto->messages->getInlineBotResults([bot: $InputUser, peer: $InputPeer, geo_point: $InputGeoPoint, query: $string, offset: $string, ]) === $messages.BotResults

$MadelineProto->messages->getInlineGameHighScores([id: $InputBotInlineMessageID, user_id: $InputUser, ]) === $messages.HighScores

$MadelineProto->messages->getMaskStickers([hash: $long, ]) === $messages.AllStickers

$MadelineProto->messages->getMessageEditData([peer: $InputPeer, id: $int, ]) === $messages.MessageEditData

$MadelineProto->messages->getMessageReactionsList([peer: $InputPeer, id: $int, reaction: $Reaction, offset: $string, limit: $int, ]) === $messages.MessageReactionsList

$MadelineProto->messages->getMessageReadParticipants([peer: $InputPeer, msg_id: $int, ]) === $Vector_of_ReadParticipantDate

$MadelineProto->messages->getMessages([id: [$InputMessage], ]) === $messages.Messages

$MadelineProto->messages->getMessagesReactions([peer: $InputPeer, id: [$int], ]) === $Updates

$MadelineProto->messages->getMessagesViews([peer: $InputPeer, id: [$int], increment: $Bool, ]) === $messages.MessageViews

$MadelineProto->messages->getMyStickers([offset_id: $long, limit: $int, ]) === $messages.MyStickers

$MadelineProto->messages->getOldFeaturedStickers([offset: $int, limit: $int, hash: $long, ]) === $messages.FeaturedStickers

$MadelineProto->messages->getOnlines([peer: $InputPeer, ]) === $ChatOnlines

$MadelineProto->messages->getOutboxReadDate([peer: $InputPeer, msg_id: $int, ]) === $OutboxReadDate

$MadelineProto->messages->getPaidReactionPrivacy([]) === $Updates

$MadelineProto->messages->getPeerDialogs([peers: [$InputDialogPeer], ]) === $messages.PeerDialogs

$MadelineProto->messages->getPeerSettings([peer: $InputPeer, ]) === $messages.PeerSettings

$MadelineProto->messages->getPinnedDialogs([folder_id: $int, ]) === $messages.PeerDialogs

$MadelineProto->messages->getPinnedSavedDialogs([]) === $messages.SavedDialogs

$MadelineProto->messages->getPollResults([peer: $InputPeer, msg_id: $int, ]) === $Updates

$MadelineProto->messages->getPollVotes([peer: $InputPeer, id: $int, option: $bytes, offset: $string, limit: $int, ]) === $messages.VotesList

$MadelineProto->messages->getPreparedInlineMessage([bot: $InputUser, id: $string, ]) === $messages.PreparedInlineMessage

$MadelineProto->messages->getQuickReplies([hash: $long, ]) === $messages.QuickReplies

$MadelineProto->messages->getQuickReplyMessages([shortcut_id: $int, id: [$int], hash: $long, ]) === $messages.Messages

$MadelineProto->messages->getRecentLocations([peer: $InputPeer, limit: $int, hash: $long, ]) === $messages.Messages

$MadelineProto->messages->getRecentReactions([limit: $int, hash: $long, ]) === $messages.Reactions

$MadelineProto->messages->getRecentStickers([attached: $Bool, hash: $long, ]) === $messages.RecentStickers

$MadelineProto->messages->getReplies([peer: $InputPeer, msg_id: $int, offset_id: $int, offset_date: $int, add_offset: $int, limit: $int, max_id: $int, min_id: $int, hash: $long, ]) === $messages.Messages

$MadelineProto->messages->getSavedDialogs([exclude_pinned: $Bool, offset_date: $int, offset_id: $int, offset_peer: $InputPeer, limit: $int, hash: $long, ]) === $messages.SavedDialogs

$MadelineProto->messages->getSavedGifs([hash: $long, ]) === $messages.SavedGifs

$MadelineProto->messages->getSavedHistory([peer: $InputPeer, offset_id: $int, offset_date: $int, add_offset: $int, limit: $int, max_id: $int, min_id: $int, hash: $long, ]) === $messages.Messages

$MadelineProto->messages->getSavedReactionTags([peer: $InputPeer, hash: $long, ]) === $messages.SavedReactionTags

$MadelineProto->messages->getScheduledHistory([peer: $InputPeer, hash: $long, ]) === $messages.Messages

$MadelineProto->messages->getScheduledMessages([peer: $InputPeer, id: [$int], ]) === $messages.Messages

$MadelineProto->messages->getSearchCounters([peer: $InputPeer, saved_peer_id: $InputPeer, top_msg_id: $int, filters: [$MessagesFilter], ]) === $Vector_of_messages.SearchCounter

$MadelineProto->messages->getSearchResultsCalendar([peer: $InputPeer, saved_peer_id: $InputPeer, filter: $MessagesFilter, offset_id: $int, offset_date: $int, ]) === $messages.SearchResultsCalendar

$MadelineProto->messages->getSearchResultsPositions([peer: $InputPeer, saved_peer_id: $InputPeer, filter: $MessagesFilter, offset_id: $int, limit: $int, ]) === $messages.SearchResultsPositions

$MadelineProto->messages->getSplitRanges([]) === $Vector_of_MessageRange

$MadelineProto->messages->getSponsoredMessages([peer: $InputPeer, ]) === $messages.SponsoredMessages

$MadelineProto->messages->getStickerSet([stickerset: $InputStickerSet, hash: $int, ]) === $messages.StickerSet

$MadelineProto->messages->getStickers([emoticon: $string, hash: $long, ]) === $messages.Stickers

$MadelineProto->messages->getSuggestedDialogFilters([]) === $Vector_of_DialogFilterSuggested

$MadelineProto->messages->getTopReactions([limit: $int, hash: $long, ]) === $messages.Reactions

$MadelineProto->messages->getUnreadMentions([peer: $InputPeer, top_msg_id: $int, offset_id: $int, add_offset: $int, limit: $int, max_id: $int, min_id: $int, ]) === $messages.Messages

$MadelineProto->messages->getUnreadReactions([peer: $InputPeer, top_msg_id: $int, offset_id: $int, add_offset: $int, limit: $int, max_id: $int, min_id: $int, ]) === $messages.Messages

$MadelineProto->messages->getWebPage([url: $string, hash: $int, ]) === $messages.WebPage

$MadelineProto->messages->getWebPagePreview([message: $string, entities: [$MessageEntity], ]) === $MessageMedia

$MadelineProto->messages->hideAllChatJoinRequests([approved: $Bool, peer: $InputPeer, link: $string, ]) === $Updates

$MadelineProto->messages->hideChatJoinRequest([approved: $Bool, peer: $InputPeer, user_id: $InputUser, ]) === $Updates

$MadelineProto->messages->hidePeerSettingsBar([peer: $InputPeer, ]) === $Bool

$MadelineProto->messages->importChatInvite([hash: $string, ]) === $Updates

$MadelineProto->messages->initHistoryImport([peer: $InputPeer, file: $InputFile, media_count: $int, ]) === $messages.HistoryImport

$MadelineProto->messages->installStickerSet([stickerset: $InputStickerSet, archived: $Bool, ]) === $messages.StickerSetInstallResult

$MadelineProto->messages->markDialogUnread([unread: $Bool, peer: $InputDialogPeer, ]) === $Bool

$MadelineProto->messages->migrateChat([chat_id: $InputPeer, ]) === $Updates

$MadelineProto->messages->prolongWebView([silent: $Bool, peer: $InputPeer, bot: $InputUser, query_id: $long, reply_to: $InputReplyTo, send_as: $InputPeer, ]) === $Bool

$MadelineProto->messages->rateTranscribedAudio([peer: $InputPeer, msg_id: $int, transcription_id: $long, good: $Bool, ]) === $Bool

$MadelineProto->messages->readDiscussion([peer: $InputPeer, msg_id: $int, read_max_id: $int, ]) === $Bool

$MadelineProto->messages->readEncryptedHistory([peer: $InputEncryptedChat, max_date: $int, ]) === $Bool

$MadelineProto->messages->readFeaturedStickers([id: [$long], ]) === $Bool

$MadelineProto->messages->readHistory([peer: $InputPeer, max_id: $int, ]) === $messages.AffectedMessages

$MadelineProto->messages->readMentions([peer: $InputPeer, top_msg_id: $int, ]) === $messages.AffectedHistory

$MadelineProto->messages->readMessageContents([id: [$int], ]) === $messages.AffectedMessages

$MadelineProto->messages->readReactions([peer: $InputPeer, top_msg_id: $int, ]) === $messages.AffectedHistory

$MadelineProto->messages->receivedMessages([max_id: $int, ]) === $Vector_of_ReceivedNotifyMessage

$MadelineProto->messages->receivedQueue([max_qts: $int, ]) === $Vector_of_long

$MadelineProto->messages->reorderPinnedDialogs([force: $Bool, folder_id: $int, order: [$InputDialogPeer], ]) === $Bool

$MadelineProto->messages->reorderPinnedSavedDialogs([force: $Bool, order: [$InputDialogPeer], ]) === $Bool

$MadelineProto->messages->reorderQuickReplies([order: [$int], ]) === $Bool

$MadelineProto->messages->reorderStickerSets([masks: $Bool, emojis: $Bool, order: [$long], ]) === $Bool

$MadelineProto->messages->report([peer: $InputPeer, id: [$int], option: $bytes, message: $string, ]) === $ReportResult

$MadelineProto->messages->reportEncryptedSpam([peer: $InputEncryptedChat, ]) === $Bool

$MadelineProto->messages->reportReaction([peer: $InputPeer, id: $int, reaction_peer: $InputPeer, ]) === $Bool

$MadelineProto->messages->reportSpam([peer: $InputPeer, ]) === $Bool

$MadelineProto->messages->reportSponsoredMessage([peer: $InputPeer, random_id: $bytes, option: $bytes, ]) === $channels.SponsoredMessageReportResult

$MadelineProto->messages->requestAppWebView([write_allowed: $Bool, compact: $Bool, fullscreen: $Bool, peer: $InputPeer, app: $InputBotApp, start_param: $string, theme_params: $DataJSON, platform: $string, ]) === $WebViewResult

$MadelineProto->messages->requestEncryption([user_id: $InputUser, g_a: $bytes, ]) === $EncryptedChat

$MadelineProto->messages->requestMainWebView([compact: $Bool, fullscreen: $Bool, peer: $InputPeer, bot: $InputUser, start_param: $string, theme_params: $DataJSON, platform: $string, ]) === $WebViewResult

$MadelineProto->messages->requestSimpleWebView([from_switch_webview: $Bool, from_side_menu: $Bool, compact: $Bool, fullscreen: $Bool, bot: $InputUser, url: $string, start_param: $string, theme_params: $DataJSON, platform: $string, ]) === $WebViewResult

$MadelineProto->messages->requestUrlAuth([peer: $InputPeer, msg_id: $int, button_id: $int, url: $string, ]) === $UrlAuthResult

$MadelineProto->messages->requestWebView([from_bot_menu: $Bool, silent: $Bool, compact: $Bool, fullscreen: $Bool, peer: $InputPeer, bot: $InputUser, url: $string, start_param: $string, theme_params: $DataJSON, platform: $string, reply_to: $InputReplyTo, send_as: $InputPeer, ]) === $WebViewResult

$MadelineProto->messages->saveDefaultSendAs([peer: $InputPeer, send_as: $InputPeer, ]) === $Bool

$MadelineProto->messages->saveDraft([no_webpage: $Bool, invert_media: $Bool, reply_to: $InputReplyTo, peer: $InputPeer, message: $string, entities: [$MessageEntity], media: $InputMedia, effect: $long, ]) === $Bool

$MadelineProto->messages->saveGif([id: $InputDocument, unsave: $Bool, ]) === $Bool

$MadelineProto->messages->savePreparedInlineMessage([result: $InputBotInlineResult, user_id: $InputUser, peer_types: [$InlineQueryPeerType], ]) === $messages.BotPreparedInlineMessage

$MadelineProto->messages->saveRecentSticker([attached: $Bool, id: $InputDocument, unsave: $Bool, ]) === $Bool

$MadelineProto->messages->search([peer: $InputPeer, q: $string, from_id: $InputPeer, saved_peer_id: $InputPeer, saved_reaction: [$Reaction], top_msg_id: $int, filter: $MessagesFilter, min_date: $int, max_date: $int, offset_id: $int, add_offset: $int, limit: $int, max_id: $int, min_id: $int, hash: $long, ]) === $messages.Messages

$MadelineProto->messages->searchCustomEmoji([emoticon: $string, hash: $long, ]) === $EmojiList

$MadelineProto->messages->searchEmojiStickerSets([exclude_featured: $Bool, q: $string, hash: $long, ]) === $messages.FoundStickerSets

$MadelineProto->messages->searchGlobal([broadcasts_only: $Bool, folder_id: $int, q: $string, filter: $MessagesFilter, min_date: $int, max_date: $int, offset_rate: $int, offset_peer: $InputPeer, offset_id: $int, limit: $int, ]) === $messages.Messages

$MadelineProto->messages->searchSentMedia([q: $string, filter: $MessagesFilter, limit: $int, ]) === $messages.Messages

$MadelineProto->messages->searchStickerSets([exclude_featured: $Bool, q: $string, hash: $long, ]) === $messages.FoundStickerSets

$MadelineProto->messages->searchStickers([emojis: $Bool, q: $string, emoticon: $string, lang_code: [$string], offset: $int, limit: $int, hash: $long, ]) === $messages.FoundStickers

$MadelineProto->messages->sendBotRequestedPeer([peer: $InputPeer, msg_id: $int, button_id: $int, requested_peers: [$InputPeer], ]) === $Updates

$MadelineProto->messages->sendEncrypted([silent: $Bool, peer: $InputEncryptedChat, data: $bytes, ]) === $messages.SentEncryptedMessage

$MadelineProto->messages->sendEncryptedFile([silent: $Bool, peer: $InputEncryptedChat, data: $bytes, file: $InputEncryptedFile, ]) === $messages.SentEncryptedMessage

$MadelineProto->messages->sendEncryptedService([peer: $InputEncryptedChat, data: $bytes, ]) === $messages.SentEncryptedMessage

$MadelineProto->messages->sendInlineBotResult([silent: $Bool, background: $Bool, clear_draft: $Bool, hide_via: $Bool, peer: $InputPeer, reply_to: $InputReplyTo, query_id: $long, id: $string, schedule_date: $int, send_as: $InputPeer, quick_reply_shortcut: $InputQuickReplyShortcut, ]) === $Updates

$MadelineProto->messages->sendMedia([silent: $Bool, background: $Bool, clear_draft: $Bool, noforwards: $Bool, update_stickersets_order: $Bool, invert_media: $Bool, allow_paid_floodskip: $Bool, peer: $InputPeer, reply_to: $InputReplyTo, media: $InputMedia, message: $string, reply_markup: $ReplyMarkup, entities: [$MessageEntity], schedule_date: $int, send_as: $InputPeer, quick_reply_shortcut: $InputQuickReplyShortcut, effect: $long, ]) === $Updates

$MadelineProto->messages->sendMessage([no_webpage: $Bool, silent: $Bool, background: $Bool, clear_draft: $Bool, noforwards: $Bool, update_stickersets_order: $Bool, invert_media: $Bool, allow_paid_floodskip: $Bool, peer: $InputPeer, reply_to: $InputReplyTo, message: $string, reply_markup: $ReplyMarkup, entities: [$MessageEntity], schedule_date: $int, send_as: $InputPeer, quick_reply_shortcut: $InputQuickReplyShortcut, effect: $long, ]) === $Updates

$MadelineProto->messages->sendMultiMedia([silent: $Bool, background: $Bool, clear_draft: $Bool, noforwards: $Bool, update_stickersets_order: $Bool, invert_media: $Bool, allow_paid_floodskip: $Bool, peer: $InputPeer, reply_to: $InputReplyTo, multi_media: [$InputSingleMedia], schedule_date: $int, send_as: $InputPeer, quick_reply_shortcut: $InputQuickReplyShortcut, effect: $long, ]) === $Updates

$MadelineProto->messages->sendPaidReaction([peer: $InputPeer, msg_id: $int, count: $int, private: $Bool, ]) === $Updates

$MadelineProto->messages->sendQuickReplyMessages([peer: $InputPeer, shortcut_id: $int, id: [$int], ]) === $Updates

$MadelineProto->messages->sendReaction([big: $Bool, add_to_recent: $Bool, peer: $InputPeer, msg_id: $int, reaction: [$Reaction], ]) === $Updates

$MadelineProto->messages->sendScheduledMessages([peer: $InputPeer, id: [$int], ]) === $Updates

$MadelineProto->messages->sendScreenshotNotification([peer: $InputPeer, reply_to: $InputReplyTo, ]) === $Updates

$MadelineProto->messages->sendVote([peer: $InputPeer, msg_id: $int, options: [$bytes], ]) === $Updates

$MadelineProto->messages->sendWebViewData([bot: $InputUser, button_text: $string, data: $string, ]) === $Updates

$MadelineProto->messages->sendWebViewResultMessage([bot_query_id: $string, result: $InputBotInlineResult, ]) === $WebViewMessageSent

$MadelineProto->messages->setBotCallbackAnswer([alert: $Bool, query_id: $long, message: $string, url: $string, cache_time: $int, ]) === $Bool

$MadelineProto->messages->setBotPrecheckoutResults([success: $Bool, query_id: $long, error: $string, ]) === $Bool

$MadelineProto->messages->setBotShippingResults([query_id: $long, error: $string, shipping_options: [$ShippingOption], ]) === $Bool

$MadelineProto->messages->setChatAvailableReactions([peer: $InputPeer, available_reactions: $ChatReactions, reactions_limit: $int, paid_enabled: $Bool, ]) === $Updates

$MadelineProto->messages->setChatTheme([peer: $InputPeer, emoticon: $string, ]) === $Updates

$MadelineProto->messages->setChatWallPaper([for_both: $Bool, revert: $Bool, peer: $InputPeer, wallpaper: $InputWallPaper, settings: $WallPaperSettings, id: $int, ]) === $Updates

$MadelineProto->messages->setDefaultHistoryTTL([period: $int, ]) === $Bool

$MadelineProto->messages->setDefaultReaction([reaction: $Reaction, ]) === $Bool

$MadelineProto->messages->setEncryptedTyping([peer: $InputEncryptedChat, typing: $Bool, ]) === $Bool

$MadelineProto->messages->setGameScore([edit_message: $Bool, force: $Bool, peer: $InputPeer, id: $int, user_id: $InputUser, score: $int, ]) === $Updates

$MadelineProto->messages->setHistoryTTL([peer: $InputPeer, period: $int, ]) === $Updates

$MadelineProto->messages->setInlineBotResults([gallery: $Bool, private: $Bool, query_id: $long, results: [$InputBotInlineResult], cache_time: $int, next_offset: $string, switch_pm: $InlineBotSwitchPM, switch_webview: $InlineBotWebView, ]) === $Bool

$MadelineProto->messages->setInlineGameScore([edit_message: $Bool, force: $Bool, id: $InputBotInlineMessageID, user_id: $InputUser, score: $int, ]) === $Bool

$MadelineProto->messages->setTyping([peer: $InputPeer, top_msg_id: $int, action: $SendMessageAction, ]) === $Bool

$MadelineProto->messages->startBot([bot: $InputUser, peer: $InputPeer, start_param: $string, ]) === $Updates

$MadelineProto->messages->startHistoryImport([peer: $InputPeer, import_id: $long, ]) === $Bool

$MadelineProto->messages->toggleBotInAttachMenu([write_allowed: $Bool, bot: $InputUser, enabled: $Bool, ]) === $Bool

$MadelineProto->messages->toggleDialogFilterTags([enabled: $Bool, ]) === $Bool

$MadelineProto->messages->toggleDialogPin([pinned: $Bool, peer: $InputDialogPeer, ]) === $Bool

$MadelineProto->messages->toggleNoForwards([peer: $InputPeer, enabled: $Bool, ]) === $Updates

$MadelineProto->messages->togglePaidReactionPrivacy([peer: $InputPeer, msg_id: $int, private: $Bool, ]) === $Bool

$MadelineProto->messages->togglePeerTranslations([disabled: $Bool, peer: $InputPeer, ]) === $Bool

$MadelineProto->messages->toggleSavedDialogPin([pinned: $Bool, peer: $InputDialogPeer, ]) === $Bool

$MadelineProto->messages->toggleStickerSets([uninstall: $Bool, archive: $Bool, unarchive: $Bool, stickersets: [$InputStickerSet], ]) === $Bool

$MadelineProto->messages->transcribeAudio([peer: $InputPeer, msg_id: $int, ]) === $messages.TranscribedAudio

$MadelineProto->messages->translateText([peer: $InputPeer, id: [$int], text: [$TextWithEntities], to_lang: $string, ]) === $messages.TranslatedText

$MadelineProto->messages->uninstallStickerSet([stickerset: $InputStickerSet, ]) === $Bool

$MadelineProto->messages->unpinAllMessages([peer: $InputPeer, top_msg_id: $int, ]) === $messages.AffectedHistory

$MadelineProto->messages->updateDialogFilter([id: $int, filter: $DialogFilter, ]) === $Bool

$MadelineProto->messages->updateDialogFiltersOrder([order: [$int], ]) === $Bool

$MadelineProto->messages->updatePinnedMessage([silent: $Bool, unpin: $Bool, pm_oneside: $Bool, peer: $InputPeer, id: $int, ]) === $Updates

$MadelineProto->messages->updateSavedReactionTag([reaction: $Reaction, title: $string, ]) === $Bool

$MadelineProto->messages->uploadEncryptedFile([peer: $InputEncryptedChat, file: $InputEncryptedFile, ]) === $EncryptedFile

$MadelineProto->messages->uploadImportedMedia([peer: $InputPeer, import_id: $long, file_name: $string, media: $InputMedia, ]) === $MessageMedia

$MadelineProto->messages->uploadMedia([business_connection_id: $string, peer: $InputPeer, media: $InputMedia, ]) === $MessageMedia

$MadelineProto->messages->viewSponsoredMessage([peer: $InputPeer, random_id: $bytes, ]) === $Bool

$MadelineProto->payments->applyGiftCode([slug: $string, ]) === $Updates

$MadelineProto->payments->assignAppStoreTransaction([receipt: $bytes, purpose: $InputStorePaymentPurpose, ]) === $Updates

$MadelineProto->payments->assignPlayMarketTransaction([receipt: $DataJSON, purpose: $InputStorePaymentPurpose, ]) === $Updates

$MadelineProto->payments->botCancelStarsSubscription([restore: $Bool, user_id: $InputUser, charge_id: $string, ]) === $Bool

$MadelineProto->payments->canPurchasePremium([purpose: $InputStorePaymentPurpose, ]) === $Bool

$MadelineProto->payments->changeStarsSubscription([peer: $InputPeer, subscription_id: $string, canceled: $Bool, ]) === $Bool

$MadelineProto->payments->checkGiftCode([slug: $string, ]) === $payments.CheckedGiftCode

$MadelineProto->payments->clearSavedInfo([credentials: $Bool, info: $Bool, ]) === $Bool

$MadelineProto->payments->connectStarRefBot([peer: $InputPeer, bot: $InputUser, ]) === $payments.ConnectedStarRefBots

$MadelineProto->payments->convertStarGift([user_id: $InputUser, msg_id: $int, ]) === $Bool

$MadelineProto->payments->editConnectedStarRefBot([revoked: $Bool, peer: $InputPeer, link: $string, ]) === $payments.ConnectedStarRefBots

$MadelineProto->payments->exportInvoice([invoice_media: $InputMedia, ]) === $payments.ExportedInvoice

$MadelineProto->payments->fulfillStarsSubscription([peer: $InputPeer, subscription_id: $string, ]) === $Bool

$MadelineProto->payments->getBankCardData([number: $string, ]) === $payments.BankCardData

$MadelineProto->payments->getConnectedStarRefBot([peer: $InputPeer, bot: $InputUser, ]) === $payments.ConnectedStarRefBots

$MadelineProto->payments->getConnectedStarRefBots([peer: $InputPeer, offset_date: $int, offset_link: $string, limit: $int, ]) === $payments.ConnectedStarRefBots

$MadelineProto->payments->getGiveawayInfo([peer: $InputPeer, msg_id: $int, ]) === $payments.GiveawayInfo

$MadelineProto->payments->getPaymentForm([invoice: $InputInvoice, theme_params: $DataJSON, ]) === $payments.PaymentForm

$MadelineProto->payments->getPaymentReceipt([peer: $InputPeer, msg_id: $int, ]) === $payments.PaymentReceipt

$MadelineProto->payments->getPremiumGiftCodeOptions([boost_peer: $InputPeer, ]) === $Vector_of_PremiumGiftCodeOption

$MadelineProto->payments->getSavedInfo([]) === $payments.SavedInfo

$MadelineProto->payments->getStarGifts([hash: $int, ]) === $payments.StarGifts

$MadelineProto->payments->getStarsGiftOptions([user_id: $InputUser, ]) === $Vector_of_StarsGiftOption

$MadelineProto->payments->getStarsGiveawayOptions([]) === $Vector_of_StarsGiveawayOption

$MadelineProto->payments->getStarsRevenueAdsAccountUrl([peer: $InputPeer, ]) === $payments.StarsRevenueAdsAccountUrl

$MadelineProto->payments->getStarsRevenueStats([dark: $Bool, peer: $InputPeer, ]) === $payments.StarsRevenueStats

$MadelineProto->payments->getStarsRevenueWithdrawalUrl([peer: $InputPeer, stars: $long, password: $InputCheckPasswordSRP, ]) === $payments.StarsRevenueWithdrawalUrl

$MadelineProto->payments->getStarsStatus([peer: $InputPeer, ]) === $payments.StarsStatus

$MadelineProto->payments->getStarsSubscriptions([missing_balance: $Bool, peer: $InputPeer, offset: $string, ]) === $payments.StarsStatus

$MadelineProto->payments->getStarsTopupOptions([]) === $Vector_of_StarsTopupOption

$MadelineProto->payments->getStarsTransactions([inbound: $Bool, outbound: $Bool, ascending: $Bool, subscription_id: $string, peer: $InputPeer, offset: $string, limit: $int, ]) === $payments.StarsStatus

$MadelineProto->payments->getStarsTransactionsByID([peer: $InputPeer, id: [$InputStarsTransaction], ]) === $payments.StarsStatus

$MadelineProto->payments->getSuggestedStarRefBots([order_by_revenue: $Bool, order_by_date: $Bool, peer: $InputPeer, offset: $string, limit: $int, ]) === $payments.SuggestedStarRefBots

$MadelineProto->payments->getUserStarGifts([user_id: $InputUser, offset: $string, limit: $int, ]) === $payments.UserStarGifts

$MadelineProto->payments->launchPrepaidGiveaway([peer: $InputPeer, giveaway_id: $long, purpose: $InputStorePaymentPurpose, ]) === $Updates

$MadelineProto->payments->refundStarsCharge([user_id: $InputUser, charge_id: $string, ]) === $Updates

$MadelineProto->payments->saveStarGift([unsave: $Bool, user_id: $InputUser, msg_id: $int, ]) === $Bool

$MadelineProto->payments->sendPaymentForm([form_id: $long, invoice: $InputInvoice, requested_info_id: $string, shipping_option_id: $string, credentials: $InputPaymentCredentials, tip_amount: $long, ]) === $payments.PaymentResult

$MadelineProto->payments->sendStarsForm([form_id: $long, invoice: $InputInvoice, ]) === $payments.PaymentResult

$MadelineProto->payments->validateRequestedInfo([save: $Bool, invoice: $InputInvoice, info: $PaymentRequestedInfo, ]) === $payments.ValidatedRequestedInfo

$MadelineProto->phone->acceptCall([peer: $InputPhoneCall, g_b: $bytes, protocol: $PhoneCallProtocol, ]) === $phone.PhoneCall

$MadelineProto->phone->checkGroupCall([call: $InputGroupCall, sources: [$int], ]) === $Vector_of_int

$MadelineProto->phone->confirmCall([peer: $InputPhoneCall, g_a: $bytes, key_fingerprint: $strlong, protocol: $PhoneCallProtocol, ]) === $phone.PhoneCall

$MadelineProto->phone->createGroupCall([rtmp_stream: $Bool, peer: $InputPeer, title: $string, schedule_date: $int, ]) === $Updates

$MadelineProto->phone->discardCall([video: $Bool, peer: $InputPhoneCall, duration: $int, reason: $PhoneCallDiscardReason, connection_id: $long, ]) === $Updates

$MadelineProto->phone->discardGroupCall([call: $InputGroupCall, ]) === $Updates

$MadelineProto->phone->editGroupCallParticipant([call: $InputGroupCall, participant: $InputPeer, muted: $Bool, volume: $int, raise_hand: $Bool, video_stopped: $Bool, video_paused: $Bool, presentation_paused: $Bool, ]) === $Updates

$MadelineProto->phone->editGroupCallTitle([call: $InputGroupCall, title: $string, ]) === $Updates

$MadelineProto->phone->exportGroupCallInvite([can_self_unmute: $Bool, call: $InputGroupCall, ]) === $phone.ExportedGroupCallInvite

$MadelineProto->phone->getCallConfig([]) === $DataJSON

$MadelineProto->phone->getGroupCall([call: $InputGroupCall, limit: $int, ]) === $phone.GroupCall

$MadelineProto->phone->getGroupCallJoinAs([peer: $InputPeer, ]) === $phone.JoinAsPeers

$MadelineProto->phone->getGroupCallStreamChannels([call: $InputGroupCall, ]) === $phone.GroupCallStreamChannels

$MadelineProto->phone->getGroupCallStreamRtmpUrl([peer: $InputPeer, revoke: $Bool, ]) === $phone.GroupCallStreamRtmpUrl

$MadelineProto->phone->getGroupParticipants([call: $InputGroupCall, ids: [$InputPeer], sources: [$int], offset: $string, limit: $int, ]) === $phone.GroupParticipants

$MadelineProto->phone->inviteToGroupCall([call: $InputGroupCall, users: [$InputUser], ]) === $Updates

$MadelineProto->phone->joinGroupCall([muted: $Bool, video_stopped: $Bool, call: $InputGroupCall, join_as: $InputPeer, invite_hash: $string, params: $DataJSON, ]) === $Updates

$MadelineProto->phone->joinGroupCallPresentation([call: $InputGroupCall, params: $DataJSON, ]) === $Updates

$MadelineProto->phone->leaveGroupCall([call: $InputGroupCall, source: $int, ]) === $Updates

$MadelineProto->phone->leaveGroupCallPresentation([call: $InputGroupCall, ]) === $Updates

$MadelineProto->phone->receivedCall([peer: $InputPhoneCall, ]) === $Bool

$MadelineProto->phone->requestCall([video: $Bool, user_id: $InputUser, g_a_hash: $bytes, protocol: $PhoneCallProtocol, ]) === $phone.PhoneCall

$MadelineProto->phone->saveCallDebug([peer: $InputPhoneCall, debug: $DataJSON, ]) === $Bool

$MadelineProto->phone->saveCallLog([peer: $InputPhoneCall, file: $InputFile, ]) === $Bool

$MadelineProto->phone->saveDefaultGroupCallJoinAs([peer: $InputPeer, join_as: $InputPeer, ]) === $Bool

$MadelineProto->phone->sendSignalingData([peer: $InputPhoneCall, data: $bytes, ]) === $Bool

$MadelineProto->phone->setCallRating([user_initiative: $Bool, peer: $InputPhoneCall, rating: $int, comment: $string, ]) === $Updates

$MadelineProto->phone->startScheduledGroupCall([call: $InputGroupCall, ]) === $Updates

$MadelineProto->phone->toggleGroupCallRecord([start: $Bool, video: $Bool, call: $InputGroupCall, title: $string, video_portrait: $Bool, ]) === $Updates

$MadelineProto->phone->toggleGroupCallSettings([reset_invite_hash: $Bool, call: $InputGroupCall, join_muted: $Bool, ]) === $Updates

$MadelineProto->phone->toggleGroupCallStartSubscription([call: $InputGroupCall, subscribed: $Bool, ]) === $Updates

$MadelineProto->photos->deletePhotos([id: [$InputPhoto], ]) === $Vector_of_long

$MadelineProto->photos->getUserPhotos([user_id: $InputUser, offset: $int, max_id: $long, limit: $int, ]) === $photos.Photos

$MadelineProto->photos->updateProfilePhoto([fallback: $Bool, bot: $InputUser, id: $InputPhoto, ]) === $photos.Photo

$MadelineProto->photos->uploadContactProfilePhoto([suggest: $Bool, save: $Bool, user_id: $InputUser, file: $InputFile, video: $InputFile, video_start_ts: $double, video_emoji_markup: $VideoSize, ]) === $photos.Photo

$MadelineProto->photos->uploadProfilePhoto([fallback: $Bool, bot: $InputUser, file: $InputFile, video: $InputFile, video_start_ts: $double, video_emoji_markup: $VideoSize, ]) === $photos.Photo

$MadelineProto->premium->applyBoost([slots: [$int], peer: $InputPeer, ]) === $premium.MyBoosts

$MadelineProto->premium->getBoostsList([gifts: $Bool, peer: $InputPeer, offset: $string, limit: $int, ]) === $premium.BoostsList

$MadelineProto->premium->getBoostsStatus([peer: $InputPeer, ]) === $premium.BoostsStatus

$MadelineProto->premium->getMyBoosts([]) === $premium.MyBoosts

$MadelineProto->premium->getUserBoosts([peer: $InputPeer, user_id: $InputUser, ]) === $premium.BoostsList

$MadelineProto->smsjobs->finishJob([job_id: $string, error: $string, ]) === $Bool

$MadelineProto->smsjobs->getSmsJob([job_id: $string, ]) === $SmsJob

$MadelineProto->smsjobs->getStatus([]) === $smsjobs.Status

$MadelineProto->smsjobs->isEligibleToJoin([]) === $smsjobs.EligibilityToJoin

$MadelineProto->smsjobs->join([]) === $Bool

$MadelineProto->smsjobs->leave([]) === $Bool

$MadelineProto->smsjobs->updateSettings([allow_international: $Bool, ]) === $Bool

$MadelineProto->stats->getBroadcastRevenueStats([dark: $Bool, peer: $InputPeer, ]) === $stats.BroadcastRevenueStats

$MadelineProto->stats->getBroadcastRevenueTransactions([peer: $InputPeer, offset: $int, limit: $int, ]) === $stats.BroadcastRevenueTransactions

$MadelineProto->stats->getBroadcastRevenueWithdrawalUrl([peer: $InputPeer, password: $InputCheckPasswordSRP, ]) === $stats.BroadcastRevenueWithdrawalUrl

$MadelineProto->stats->getBroadcastStats([dark: $Bool, channel: $InputChannel, ]) === $stats.BroadcastStats

$MadelineProto->stats->getMegagroupStats([dark: $Bool, channel: $InputChannel, ]) === $stats.MegagroupStats

$MadelineProto->stats->getMessagePublicForwards([channel: $InputChannel, msg_id: $int, offset: $string, limit: $int, ]) === $stats.PublicForwards

$MadelineProto->stats->getMessageStats([dark: $Bool, channel: $InputChannel, msg_id: $int, ]) === $stats.MessageStats

$MadelineProto->stats->getStoryPublicForwards([peer: $InputPeer, id: $int, offset: $string, limit: $int, ]) === $stats.PublicForwards

$MadelineProto->stats->getStoryStats([dark: $Bool, peer: $InputPeer, id: $int, ]) === $stats.StoryStats

$MadelineProto->stats->loadAsyncGraph([token: $string, x: $long, ]) === $StatsGraph

$MadelineProto->stickers->addStickerToSet([stickerset: $InputStickerSet, sticker: $InputStickerSetItem, ]) === $messages.StickerSet

$MadelineProto->stickers->changeSticker([sticker: $InputDocument, emoji: $string, mask_coords: $MaskCoords, keywords: $string, ]) === $messages.StickerSet

$MadelineProto->stickers->changeStickerPosition([sticker: $InputDocument, position: $int, ]) === $messages.StickerSet

$MadelineProto->stickers->checkShortName([short_name: $string, ]) === $Bool

$MadelineProto->stickers->createStickerSet([masks: $Bool, emojis: $Bool, text_color: $Bool, user_id: $InputUser, title: $string, short_name: $string, thumb: $InputDocument, stickers: [$InputStickerSetItem], software: $string, ]) === $messages.StickerSet

$MadelineProto->stickers->deleteStickerSet([stickerset: $InputStickerSet, ]) === $Bool

$MadelineProto->stickers->removeStickerFromSet([sticker: $InputDocument, ]) === $messages.StickerSet

$MadelineProto->stickers->renameStickerSet([stickerset: $InputStickerSet, title: $string, ]) === $messages.StickerSet

$MadelineProto->stickers->replaceSticker([sticker: $InputDocument, new_sticker: $InputStickerSetItem, ]) === $messages.StickerSet

$MadelineProto->stickers->setStickerSetThumb([stickerset: $InputStickerSet, thumb: $InputDocument, thumb_document_id: $long, ]) === $messages.StickerSet

$MadelineProto->stickers->suggestShortName([title: $string, ]) === $stickers.SuggestedShortName

$MadelineProto->stories->activateStealthMode([past: $Bool, future: $Bool, ]) === $Updates

$MadelineProto->stories->canSendStory([peer: $InputPeer, ]) === $Bool

$MadelineProto->stories->deleteStories([peer: $InputPeer, id: [$int], ]) === $Vector_of_int

$MadelineProto->stories->editStory([peer: $InputPeer, id: $int, media: $InputMedia, media_areas: [$MediaArea], caption: $string, entities: [$MessageEntity], privacy_rules: [$InputPrivacyRule], ]) === $Updates

$MadelineProto->stories->exportStoryLink([peer: $InputPeer, id: $int, ]) === $ExportedStoryLink

$MadelineProto->stories->getAllReadPeerStories([]) === $Updates

$MadelineProto->stories->getAllStories([next: $Bool, hidden: $Bool, state: $string, ]) === $stories.AllStories

$MadelineProto->stories->getChatsToSend([]) === $messages.Chats

$MadelineProto->stories->getPeerMaxIDs([id: [$InputPeer], ]) === $Vector_of_int

$MadelineProto->stories->getPeerStories([peer: $InputPeer, ]) === $stories.PeerStories

$MadelineProto->stories->getPinnedStories([peer: $InputPeer, offset_id: $int, limit: $int, ]) === $stories.Stories

$MadelineProto->stories->getStoriesArchive([peer: $InputPeer, offset_id: $int, limit: $int, ]) === $stories.Stories

$MadelineProto->stories->getStoriesByID([peer: $InputPeer, id: [$int], ]) === $stories.Stories

$MadelineProto->stories->getStoriesViews([peer: $InputPeer, id: [$int], ]) === $stories.StoryViews

$MadelineProto->stories->getStoryReactionsList([forwards_first: $Bool, peer: $InputPeer, id: $int, reaction: $Reaction, offset: $string, limit: $int, ]) === $stories.StoryReactionsList

$MadelineProto->stories->getStoryViewsList([just_contacts: $Bool, reactions_first: $Bool, forwards_first: $Bool, peer: $InputPeer, q: $string, id: $int, offset: $string, limit: $int, ]) === $stories.StoryViewsList

$MadelineProto->stories->incrementStoryViews([peer: $InputPeer, id: [$int], ]) === $Bool

$MadelineProto->stories->readStories([peer: $InputPeer, max_id: $int, ]) === $Vector_of_int

$MadelineProto->stories->report([peer: $InputPeer, id: [$int], option: $bytes, message: $string, ]) === $ReportResult

$MadelineProto->stories->searchPosts([hashtag: $string, area: $MediaArea, peer: $InputPeer, offset: $string, limit: $int, ]) === $stories.FoundStories

$MadelineProto->stories->sendReaction([add_to_recent: $Bool, peer: $InputPeer, story_id: $int, reaction: $Reaction, ]) === $Updates

$MadelineProto->stories->sendStory([pinned: $Bool, noforwards: $Bool, fwd_modified: $Bool, peer: $InputPeer, media: $InputMedia, media_areas: [$MediaArea], caption: $string, entities: [$MessageEntity], privacy_rules: [$InputPrivacyRule], period: $int, fwd_from_id: $InputPeer, fwd_from_story: $int, ]) === $Updates

$MadelineProto->stories->toggleAllStoriesHidden([hidden: $Bool, ]) === $Bool

$MadelineProto->stories->togglePeerStoriesHidden([peer: $InputPeer, hidden: $Bool, ]) === $Bool

$MadelineProto->stories->togglePinned([peer: $InputPeer, id: [$int], pinned: $Bool, ]) === $Vector_of_int

$MadelineProto->stories->togglePinnedToTop([peer: $InputPeer, id: [$int], ]) === $Bool

$MadelineProto->updates->getChannelDifference([force: $Bool, channel: $InputChannel, filter: $ChannelMessagesFilter, pts: $int, limit: $int, ]) === $updates.ChannelDifference

$MadelineProto->updates->getDifference([pts: $int, pts_limit: $int, pts_total_limit: $int, date: $int, qts: $int, qts_limit: $int, ]) === $updates.Difference

$MadelineProto->updates->getState([]) === $updates.State

$MadelineProto->upload->getCdnFile([file_token: $string, offset: $long, limit: $int, ]) === $upload.CdnFile

$MadelineProto->upload->getCdnFileHashes([file_token: $string, offset: $long, ]) === $Vector_of_FileHash

$MadelineProto->upload->getFile([precise: $Bool, cdn_supported: $Bool, location: $InputFileLocation, offset: $long, limit: $int, ]) === $upload.File

$MadelineProto->upload->getFileHashes([location: $InputFileLocation, offset: $long, ]) === $Vector_of_FileHash

$MadelineProto->upload->getWebFile([location: $InputWebFileLocation, offset: $int, limit: $int, ]) === $upload.WebFile

$MadelineProto->upload->reuploadCdnFile([file_token: $string, request_token: $bytes, ]) === $Vector_of_FileHash

$MadelineProto->upload->saveBigFilePart([file_id: $long, file_part: $int, file_total_parts: $int, bytes: $bytes, ]) === $Bool

$MadelineProto->upload->saveFilePart([file_id: $long, file_part: $int, bytes: $bytes, ]) === $Bool

$MadelineProto->users->getFullUser([id: $InputUser, ]) === $users.UserFull

$MadelineProto->users->getIsPremiumRequiredToContact([id: [$InputUser], ]) === $Vector_of_Bool

$MadelineProto->users->getUsers([id: [$InputUser], ]) === $Vector_of_User

$MadelineProto->users->setSecureValueErrors([id: $InputUser, errors: [$SecureValueError], ]) === $Bool