InternalDoc.php

<?php declare(strict_types=1);
/**
 * This file is automatically generated by the build_docs.php file
 * and is used only for autocompletion in multiple IDEs
 * don't modify it manually.
 *
 * @generated Automatically generated by build_docs.php — do not edit.
 */

namespace danog\MadelineProto;

use __PHP_Incomplete_Class;
use Amp\ByteStream\Pipe;
use Amp\ByteStream\ReadableStream;
use Amp\ByteStream\WritableStream;
use Amp\Cancellation;
use Amp\Future;
use Amp\Http\Server\Request as ServerRequest;
use Closure;
use danog\MadelineProto\Broadcast\Action;
use danog\MadelineProto\Broadcast\Progress;
use danog\MadelineProto\Broadcast\Status;
use danog\MadelineProto\EventHandler\Action\Cancel;
use danog\MadelineProto\EventHandler\Attributes\Handler;
use danog\MadelineProto\EventHandler\Calls\AbstractGroupCall;
use danog\MadelineProto\EventHandler\Calls\AbstractGroupCallParticipant;
use danog\MadelineProto\EventHandler\Calls\GroupCall;
use danog\MadelineProto\EventHandler\Calls\PrivateCall;
use danog\MadelineProto\EventHandler\Calls\RtmpStream;
use danog\MadelineProto\EventHandler\Keyboard;
use danog\MadelineProto\EventHandler\Media;
use danog\MadelineProto\EventHandler\Media\Audio;
use danog\MadelineProto\EventHandler\Media\Document;
use danog\MadelineProto\EventHandler\Media\Gif;
use danog\MadelineProto\EventHandler\Media\Photo;
use danog\MadelineProto\EventHandler\Media\Sticker;
use danog\MadelineProto\EventHandler\Media\Thumbnail;
use danog\MadelineProto\EventHandler\Media\Video;
use danog\MadelineProto\EventHandler\Media\Voice;
use danog\MadelineProto\EventHandler\Message;
use danog\MadelineProto\EventHandler\Message\Entities\Code;
use danog\MadelineProto\EventHandler\Message\Entities\Email;
use danog\MadelineProto\EventHandler\Message\Entities\Mention;
use danog\MadelineProto\EventHandler\Message\Entities\MessageEntity;
use danog\MadelineProto\EventHandler\Message\Entities\Phone;
use danog\MadelineProto\EventHandler\Message\Entities\Pre;
use danog\MadelineProto\EventHandler\Message\Entities\Spoiler;
use danog\MadelineProto\EventHandler\Message\Entities\Unknown;
use danog\MadelineProto\EventHandler\Message\Entities\Url;
use danog\MadelineProto\EventHandler\Participant;
use danog\MadelineProto\EventHandler\Participant\Admin;
use danog\MadelineProto\EventHandler\Participant\Member;
use danog\MadelineProto\EventHandler\Pinned;
use danog\MadelineProto\EventHandler\Story\Story;
use danog\MadelineProto\EventHandler\Update;
use danog\MadelineProto\EventHandler\User\Status\Emoji;
use danog\MadelineProto\EventHandler\User\Username;
use danog\MadelineProto\Ipc\Client;
use danog\MadelineProto\Ipc\EventHandlerProxy;
use danog\MadelineProto\Ipc\Server;

/** @psalm-suppress PossiblyNullReference, PropertyNotSetInConstructor */
abstract class InternalDoc
{
    protected APIWrapper $wrapper;
    /** @var \danog\MadelineProto\Namespace\Auth $auth */
    public $auth;
    /** @var \danog\MadelineProto\Namespace\Account $account */
    public $account;
    /** @var \danog\MadelineProto\Namespace\Users $users */
    public $users;
    /** @var \danog\MadelineProto\Namespace\Contacts $contacts */
    public $contacts;
    /** @var \danog\MadelineProto\Namespace\Messages $messages */
    public $messages;
    /** @var \danog\MadelineProto\Namespace\Updates $updates */
    public $updates;
    /** @var \danog\MadelineProto\Namespace\Photos $photos */
    public $photos;
    /** @var \danog\MadelineProto\Namespace\Upload $upload */
    public $upload;
    /** @var \danog\MadelineProto\Namespace\Help $help */
    public $help;
    /** @var \danog\MadelineProto\Namespace\Channels $channels */
    public $channels;
    /** @var \danog\MadelineProto\Namespace\Bots $bots */
    public $bots;
    /** @var \danog\MadelineProto\Namespace\Payments $payments */
    public $payments;
    /** @var \danog\MadelineProto\Namespace\Stickers $stickers */
    public $stickers;
    /** @var \danog\MadelineProto\Namespace\Phone $phone */
    public $phone;
    /** @var \danog\MadelineProto\Namespace\Langpack $langpack */
    public $langpack;
    /** @var \danog\MadelineProto\Namespace\Folders $folders */
    public $folders;
    /** @var \danog\MadelineProto\Namespace\Stats $stats */
    public $stats;
    /** @var \danog\MadelineProto\Namespace\Chatlists $chatlists */
    public $chatlists;
    /** @var \danog\MadelineProto\Namespace\Stories $stories */
    public $stories;
    /** @var \danog\MadelineProto\Namespace\Premium $premium */
    public $premium;
    /** @var \danog\MadelineProto\Namespace\Smsjobs $smsjobs */
    public $smsjobs;
    /** @var \danog\MadelineProto\Namespace\Fragment $fragment */
    public $fragment;
    /** @var \danog\MadelineProto\Namespace\Aicompose $aicompose */
    public $aicompose;
    /** @var \danog\MadelineProto\Namespace\Communities $communities */
    public $communities;
    /** @var \danog\MadelineProto\Namespace\Ephemeral $ephemeral */
    public $ephemeral;
    /** @var \danog\MadelineProto\Namespace\Toncenter $toncenter */
    public $toncenter;
    /** @var \danog\MadelineProto\Namespace\Wallet $wallet */
    public $wallet;

    /**
     * Export APIFactory instance with the specified namespace.
     * @psalm-suppress InaccessibleProperty
     */
    protected function exportNamespaces(): void
    {
        $this->auth ??= new \danog\MadelineProto\Namespace\AbstractAPI('auth');
        $this->auth->setWrapper($this->wrapper);
        $this->account ??= new \danog\MadelineProto\Namespace\AbstractAPI('account');
        $this->account->setWrapper($this->wrapper);
        $this->users ??= new \danog\MadelineProto\Namespace\AbstractAPI('users');
        $this->users->setWrapper($this->wrapper);
        $this->contacts ??= new \danog\MadelineProto\Namespace\AbstractAPI('contacts');
        $this->contacts->setWrapper($this->wrapper);
        $this->messages ??= new \danog\MadelineProto\Namespace\AbstractAPI('messages');
        $this->messages->setWrapper($this->wrapper);
        $this->updates ??= new \danog\MadelineProto\Namespace\AbstractAPI('updates');
        $this->updates->setWrapper($this->wrapper);
        $this->photos ??= new \danog\MadelineProto\Namespace\AbstractAPI('photos');
        $this->photos->setWrapper($this->wrapper);
        $this->upload ??= new \danog\MadelineProto\Namespace\AbstractAPI('upload');
        $this->upload->setWrapper($this->wrapper);
        $this->help ??= new \danog\MadelineProto\Namespace\AbstractAPI('help');
        $this->help->setWrapper($this->wrapper);
        $this->channels ??= new \danog\MadelineProto\Namespace\AbstractAPI('channels');
        $this->channels->setWrapper($this->wrapper);
        $this->bots ??= new \danog\MadelineProto\Namespace\AbstractAPI('bots');
        $this->bots->setWrapper($this->wrapper);
        $this->payments ??= new \danog\MadelineProto\Namespace\AbstractAPI('payments');
        $this->payments->setWrapper($this->wrapper);
        $this->stickers ??= new \danog\MadelineProto\Namespace\AbstractAPI('stickers');
        $this->stickers->setWrapper($this->wrapper);
        $this->phone ??= new \danog\MadelineProto\Namespace\AbstractAPI('phone');
        $this->phone->setWrapper($this->wrapper);
        $this->langpack ??= new \danog\MadelineProto\Namespace\AbstractAPI('langpack');
        $this->langpack->setWrapper($this->wrapper);
        $this->folders ??= new \danog\MadelineProto\Namespace\AbstractAPI('folders');
        $this->folders->setWrapper($this->wrapper);
        $this->stats ??= new \danog\MadelineProto\Namespace\AbstractAPI('stats');
        $this->stats->setWrapper($this->wrapper);
        $this->chatlists ??= new \danog\MadelineProto\Namespace\AbstractAPI('chatlists');
        $this->chatlists->setWrapper($this->wrapper);
        $this->stories ??= new \danog\MadelineProto\Namespace\AbstractAPI('stories');
        $this->stories->setWrapper($this->wrapper);
        $this->premium ??= new \danog\MadelineProto\Namespace\AbstractAPI('premium');
        $this->premium->setWrapper($this->wrapper);
        $this->smsjobs ??= new \danog\MadelineProto\Namespace\AbstractAPI('smsjobs');
        $this->smsjobs->setWrapper($this->wrapper);
        $this->fragment ??= new \danog\MadelineProto\Namespace\AbstractAPI('fragment');
        $this->fragment->setWrapper($this->wrapper);
        $this->aicompose ??= new \danog\MadelineProto\Namespace\AbstractAPI('aicompose');
        $this->aicompose->setWrapper($this->wrapper);
        $this->communities ??= new \danog\MadelineProto\Namespace\AbstractAPI('communities');
        $this->communities->setWrapper($this->wrapper);
        $this->ephemeral ??= new \danog\MadelineProto\Namespace\AbstractAPI('ephemeral');
        $this->ephemeral->setWrapper($this->wrapper);
        $this->toncenter ??= new \danog\MadelineProto\Namespace\AbstractAPI('toncenter');
        $this->toncenter->setWrapper($this->wrapper);
        $this->wallet ??= new \danog\MadelineProto\Namespace\AbstractAPI('wallet');
        $this->wallet->setWrapper($this->wrapper);
    }
    /**
         * Convert MTProto parameters to bot API parameters.
         *
         * @param array $data Data
         */
    final public function MTProtoToBotAPI(array $data): array
    {
        return $this->wrapper->getAPI()->MTProtoToBotAPI($data);
    }
    /**
     * MTProto to TD params.
     *
     * @param mixed $params Params
     */
    final public function MTProtoToTd(mixed &$params): array
    {
        return $this->wrapper->getAPI()->MTProtoToTd($params);
    }
    /**
     * MTProto to TDCLI params.
     *
     * @param mixed $params Params
     */
    final public function MTProtoToTdcli(mixed $params): array
    {
        return $this->wrapper->getAPI()->MTProtoToTdcli($params);
    }
    /**
     * Accept call.
     */
    final public function acceptCall(int $id, ?\Amp\Cancellation $cancellation = null): void
    {
        $this->wrapper->getAPI()->acceptCall($id, $cancellation);
    }
    /**
     * Accept secret chat.
     *
     * @param array $params Secret chat ID
     */
    final public function acceptSecretChat(array $params): void
    {
        $this->wrapper->getAPI()->acceptSecretChat($params);
    }
    /**
     * Create array.
     *
     * @param mixed ...$params Params
     *
     * @psalm-pure
     */
    final public static function arr(mixed ...$params): array
    {
        return \danog\MadelineProto\Tools::arr(...$params);
    }
    /**
     * base64URL decode.
     *
     * @param string $data Data to decode
     *
     * @psalm-pure
     */
    final public static function base64urlDecode(string $data): string
    {
        return \danog\MadelineProto\Tools::base64urlDecode($data);
    }
    /**
     * Base64URL encode.
     *
     * @param string $data Data to encode
     *
     * @psalm-pure
     */
    final public static function base64urlEncode(string $data): string
    {
        return \danog\MadelineProto\Tools::base64urlEncode($data);
    }
    /**
     * Convert bot API parameters to MTProto parameters.
     *
     * @param array $arguments Arguments
     */
    final public function botAPIToMTProto(array $arguments): array
    {
        return $this->wrapper->getAPI()->botAPIToMTProto($arguments);
    }
    /**
     * Login as bot.
     *
     * @param string $token Bot token
     */
    final public function botLogin(#[\SensitiveParameter] string $token): ?array
    {
        return $this->wrapper->getAPI()->botLogin($token);
    }
    /**
     * Executes a custom broadcast action with all peers (users, chats, channels) of the bot.
     *
     * Will return an integer ID that can be used to:
     *
     * - Get the current broadcast progress with getBroadcastProgress
     * - Cancel the broadcast using cancelBroadcast
     *
     * Note that to avoid manually polling the progress,
     * MadelineProto will also periodically emit updateBroadcastProgress updates,
     * containing a Progress object for all broadcasts currently in-progress.
     *
     * @param Action $action A custom, serializable Action class that will be called once for every peer.
     * @param float|null $delay Number of seconds to wait between each peer.
     */
    final public function broadcastCustom(\danog\MadelineProto\Broadcast\Action $action, ?\danog\MadelineProto\Broadcast\Filter $filter = null, ?float $delay = null): int
    {
        return $this->wrapper->getAPI()->broadcastCustom($action, $filter, $delay);
    }
    /**
     * Forwards a list of messages to all peers (users, chats, channels) of the bot.
     *
     * Will return an integer ID that can be used to:
     *
     * - Get the current broadcast progress with getBroadcastProgress
     * - Cancel the broadcast using cancelBroadcast
     *
     * Note that to avoid manually polling the progress,
     * MadelineProto will also periodically emit updateBroadcastProgress updates,
     * containing a Progress object for all broadcasts currently in-progress.
     *
     * @param mixed      $from_peer   Bot API ID or Update, from where to forward the messages.
     * @param list<int>  $message_ids IDs of the messages to forward.
     * @param bool       $drop_author If true, will forward messages without quoting the original author.
     * @param bool       $pin         Whether to also pin the last sent message.
     * @param float|null $delay       Number of seconds to wait between each peer.
     */
    final public function broadcastForwardMessages(mixed $from_peer, array $message_ids, bool $drop_author = false, ?\danog\MadelineProto\Broadcast\Filter $filter = null, bool $pin = false, ?float $delay = null): int
    {
        return $this->wrapper->getAPI()->broadcastForwardMessages($from_peer, $message_ids, $drop_author, $filter, $pin, $delay);
    }
    /**
     * Sends a list of messages to all peers (users, chats, channels) of the bot.
     *
     * A simplified version of this method is also available: broadcastForwardMessages can work with pre-prepared messages.
     *
     * Will return an integer ID that can be used to:
     *
     * - Get the current broadcast progress with getBroadcastProgress
     * - Cancel the broadcast using cancelBroadcast
     *
     * Note that to avoid manually polling the progress,
     * MadelineProto will also periodically emit updateBroadcastProgress updates,
     * containing a Progress object for all broadcasts currently in-progress.
     *
     * @param array         $messages The messages to send: an array of arrays, containing parameters to pass to messages.sendMessage.
     * @param bool          $pin      Whether to also pin the last sent message.
     * @param float|null    $delay    Number of seconds to wait between each peer.
     */
    final public function broadcastMessages(array $messages, ?\danog\MadelineProto\Broadcast\Filter $filter = null, bool $pin = false, ?float $delay = null): int
    {
        return $this->wrapper->getAPI()->broadcastMessages($messages, $filter, $pin, $delay);
    }
    /**
     * Fork a new green thread and execute the passed function in the background.
     *
     * @template T
     *
     * @param \Closure(...):T $callable Function to execute
     * @param mixed ...$args Arguments forwarded to the function when forking the thread.
     *
     * @return Future<T>
     *
     * @psalm-suppress InvalidScope
     */
    final public static function callFork(\Generator|\Amp\Future|callable $callable, ...$args): \Amp\Future
    {
        return \danog\MadelineProto\AsyncTools::callFork($callable, ...$args);
    }
    /**
     * Get the file that is currently being played.
     *
     * Will return a string with the object ID of the stream if we're currently playing a stream, otherwise returns the related LocalFile or RemoteUrl.
     *
     * @psalm-mutation-free
     */
    final public function callGetCurrent(int $id, \danog\MadelineProto\MediaDestination $dest = \danog\MadelineProto\MediaDestination::Camera): \danog\MadelineProto\RemoteUrl|\danog\MadelineProto\LocalFile|string|null
    {
        return $this->wrapper->getAPI()->callGetCurrent($id, $dest);
    }
    /**
     * Play file in call.
     */
    final public function callPlay(int $id, \danog\MadelineProto\LocalFile|\danog\MadelineProto\RemoteUrl|\Amp\ByteStream\ReadableStream $file, \danog\MadelineProto\MediaDestination $dest = \danog\MadelineProto\MediaDestination::Camera): void
    {
        $this->wrapper->getAPI()->callPlay($id, $file, $dest);
    }
    /**
     * Play files on hold in call.
     */
    final public function callPlayOnHold(int $id, \danog\MadelineProto\MediaDestination $dest = \danog\MadelineProto\MediaDestination::Camera, \danog\MadelineProto\LocalFile|\danog\MadelineProto\RemoteUrl|\Amp\ByteStream\ReadableStream ...$files): void
    {
        $this->wrapper->getAPI()->callPlayOnHold($id, $dest, ...$files);
    }
    /**
     * Record the incoming media of a call into one file (or stream) with a fixed set of tracks, see
     * {@see \danog\MadelineProto\EventHandler\Calls\PrivateCall::setOutput()}.
     *
     * @param ?StreamMask $streams The streams to record, as a bitmask of {@see CallStream} flags, or null for every available one.
     *
     * @return StreamMask The streams the other party currently sends, as a bitmask of {@see CallStream} flags (0 while unknown).
     */
    final public function callSetOutput(int $id, \danog\MadelineProto\LocalFile|\Amp\ByteStream\WritableStream $file, ?\danog\MadelineProto\RecordingFormat $format = null, ?int $streams = null): int
    {
        return $this->wrapper->getAPI()->callSetOutput($id, $file, $format, $streams);
    }
    /**
     * Record the incoming media of a call into a directory, one numbered file per combination of
     * streams the other party sends, see {@see \danog\MadelineProto\EventHandler\Calls\PrivateCall::setOutputFolder()}.
     */
    final public function callSetOutputFolder(int $id, \danog\MadelineProto\LocalDirectory $dir, ?\danog\MadelineProto\RecordingFormat $format = null): void
    {
        $this->wrapper->getAPI()->callSetOutputFolder($id, $dir, $format);
    }
    /**
     * Whether we can convert any audio/video file to a VoIP OGG OPUS file, or the files must be preconverted using @libtgvoipbot.
     */
    final public static function canConvertOgg(): bool
    {
        return \danog\MadelineProto\Tools::canConvertOgg();
    }
    /**
     * Whether we can convert any audio/video file using ffmpeg.
     */
    final public static function canUseFFmpeg(?\Amp\Cancellation $cancellation = null): bool
    {
        return \danog\MadelineProto\Tools::canUseFFmpeg($cancellation);
    }
    /**
     * Cancel a running broadcast.
     *
     * @param integer $id Broadcast ID
     *
     */
    final public function cancelBroadcast(int $id): void
    {
        $this->wrapper->getAPI()->cancelBroadcast($id);
    }
    /**
     * Close connection with client, connected via web.
     *
     * @param string $message Message
     */
    final public static function closeConnection(string $message): void
    {
        \danog\MadelineProto\Tools::closeConnection($message);
    }
    /**
     * Stop publishing to an RTMP stream for good.
     *
     * See {@see RtmpStream::close()}.
     */
    final public function closeRtmpStream(int $id): void
    {
        $this->wrapper->getAPI()->closeRtmpStream($id);
    }
    /**
     * Complete 2FA login.
     *
     * @param string $password Password
     */
    final public function complete2faLogin(#[\SensitiveParameter] string $password): array
    {
        return $this->wrapper->getAPI()->complete2faLogin($password);
    }
    /**
     * Complet user login using login code.
     *
     * @param string $code Login code
     */
    final public function completePhoneLogin(#[\SensitiveParameter] string $code): array
    {
        return $this->wrapper->getAPI()->completePhoneLogin($code);
    }
    /**
     * Complete signup to Telegram.
     *
     * @param string $first_name First name
     * @param string $last_name  Last name
     */
    final public function completeSignup(string $first_name, string $last_name = ''): array
    {
        return $this->wrapper->getAPI()->completeSignup($first_name, $last_name);
    }
    /**
     * Create and join a new end-to-end encrypted conference call, with ourselves as the only
     * participant. Others join it with {@see self::joinConferenceCall()} using the returned call id.
     *
     * See [end-to-end encrypted group calls »](https://core.telegram.org/api/end-to-end/group-calls).
     * Uses the `sodium` and `openssl` PHP extensions if available, for speed.
     *
     * @param bool $muted Whether to join muted.
     */
    final public function createConferenceCall(bool $muted = false): \danog\MadelineProto\EventHandler\Calls\ConferenceCall
    {
        return $this->wrapper->getAPI()->createConferenceCall($muted);
    }
    /**
     * Create a group call (video chat or livestream) in the specified group or channel.
     *
     * Requires the `manage_call` admin right, see
     * [video chats/livestreams »](https://core.telegram.org/api/group-calls#video-chats-livestreams).
     *
     * @param string|int       $peer         The group or channel where the call should be created.
     * @param string|null $title        Custom title, defaults to the group/channel name.
     * @param int|null    $scheduleDate If set, creates a scheduled call for the specified UNIX timestamp.
     * @param bool        $rtmpStream   Whether the call's media is published by an external RTMP application.
     */
    final public function createGroupCall(string|int $peer, ?string $title = null, ?int $scheduleDate = null, bool $rtmpStream = false): \danog\MadelineProto\EventHandler\Calls\GroupCall
    {
        return $this->wrapper->getAPI()->createGroupCall($peer, $title, $scheduleDate, $rtmpStream);
    }
    /**
     * Decline an invitation to a conference call.
     *
     * @param int $msgId ID of the invitation message (a `messageActionConferenceCall`).
     */
    final public function declineConferenceCallInvite(int $msgId): void
    {
        $this->wrapper->getAPI()->declineConferenceCallInvite($msgId);
    }
    /**
     * Discard call.
     *
     * @param int<1, 5> $rating  Call rating in stars
     * @param string    $comment Additional comment on call quality.
     */
    final public function discardCall(int $id, \danog\MadelineProto\VoIP\DiscardReason $reason = \danog\MadelineProto\VoIP\DiscardReason::HANGUP, ?int $rating = null, ?string $comment = null): void
    {
        $this->wrapper->getAPI()->discardCall($id, $reason, $rating, $comment);
    }
    /**
     * End a group call for all participants.
     */
    final public function discardGroupCall(int $id): void
    {
        $this->wrapper->getAPI()->discardGroupCall($id);
    }
    /**
     * Discard secret chat.
     *
     * @param int $chat Secret chat ID
     * @param bool $deleteHistory If true, deletes the entire chat history for the other user as well.
     */
    final public function discardSecretChat(int $chat, bool $deleteHistory = false): void
    {
        $this->wrapper->getAPI()->discardSecretChat($chat, $deleteHistory);
    }
    /**
     * Downloads a file to the browser using the specified session file.
     */
    final public static function downloadServer(string $session): void
    {
        \danog\MadelineProto\MTProto::downloadServer($session);
    }
    /**
     * Download file to browser.
     *
     * Supports HEAD requests and content-ranges for parallel and resumed downloads.
     *
     * @param array|string|FileCallbackInterface|\danog\MadelineProto\EventHandler\Message $messageMedia File to download
     * @param null|callable                                                                $cb           Status callback (can also use FileCallback)
     * @param null|int                                                                     $size         Size of file to download, required for bot API file IDs.
     * @param null|string                                                                  $mime         MIME type of file to download, required for bot API file IDs.
     * @param null|string                                                                  $name         Name of file to download, required for bot API file IDs.
     */
    final public function downloadToBrowser(\danog\MadelineProto\FileCallbackInterface|\danog\MadelineProto\EventHandler\Message|array|string $messageMedia, ?callable $cb = null, ?int $size = null, ?string $name = null, ?string $mime = null, ?\Amp\Cancellation $cancellation = null): void
    {
        $this->wrapper->getAPI()->downloadToBrowser($messageMedia, $cb, $size, $name, $mime, $cancellation);
    }
    /**
     * Download file to callable.
     * The callable must accept two parameters: string $payload, int $offset
     * The callable will be called (possibly out of order, depending on the value of $seekable).
     *
     * @param mixed                          $messageMedia File to download
     * @param callable|FileCallbackInterface $callable     Chunk callback
     * @param callable                       $cb           Status callback
     * @param bool                           $seekable     Whether the callable can be called out of order
     * @param int                            $offset       Offset where to start downloading
     * @param int                            $end          Offset where to stop downloading (inclusive)
     * @param int                            $part_size    Size of each chunk
     */
    final public function downloadToCallable(mixed $messageMedia, callable $callable, ?callable $cb = null, bool $seekable = true, int $offset = 0, int $end = -1, ?int $part_size = null, ?\Amp\Cancellation $cancellation = null): void
    {
        $this->wrapper->getAPI()->downloadToCallable($messageMedia, $callable, $cb, $seekable, $offset, $end, $part_size, $cancellation);
    }
    /**
     * Download file to directory.
     *
     * @param mixed                        $messageMedia File to download
     * @param string|FileCallbackInterface $dir          Directory where to download the file
     * @param callable                     $cb           Callback
     *
     * @return non-empty-string Downloaded file name
     */
    final public function downloadToDir(mixed $messageMedia, \danog\MadelineProto\FileCallbackInterface|string $dir, ?callable $cb = null, ?\Amp\Cancellation $cancellation = null): string
    {
        return $this->wrapper->getAPI()->downloadToDir($messageMedia, $dir, $cb, $cancellation);
    }
    /**
     * Download file.
     *
     * @param mixed                        $messageMedia File to download
     * @param string|FileCallbackInterface $file         Downloaded file path
     * @param callable                     $cb           Callback
     *
     * @return non-empty-string Downloaded file name
     */
    final public function downloadToFile(mixed $messageMedia, \danog\MadelineProto\FileCallbackInterface|string $file, ?callable $cb = null, ?\Amp\Cancellation $cancellation = null): string
    {
        return $this->wrapper->getAPI()->downloadToFile($messageMedia, $file, $cb, $cancellation);
    }
    /**
     * Download file to amphp/http-server response.
     *
     * Supports HEAD requests and content-ranges for parallel and resumed downloads.
     *
     * @param array|string|FileCallbackInterface|\danog\MadelineProto\EventHandler\Message $messageMedia File to download
     * @param ServerRequest                                                                $request      Request
     * @param callable                                                                     $cb           Status callback (can also use FileCallback)
     * @param null|int                                                                     $size         Size of file to download, required for bot API file IDs.
     * @param null|string                                                                  $name         Name of file to download, required for bot API file IDs.
     * @param null|string                                                                  $mime         MIME type of file to download, required for bot API file IDs.
     */
    final public function downloadToResponse(\danog\MadelineProto\FileCallbackInterface|\danog\MadelineProto\EventHandler\Message|array|string $messageMedia, \Amp\Http\Server\Request $request, ?callable $cb = null, ?int $size = null, ?string $mime = null, ?string $name = null, ?\Amp\Cancellation $cancellation = null): \Amp\Http\Server\Response
    {
        return $this->wrapper->getAPI()->downloadToResponse($messageMedia, $request, $cb, $size, $mime, $name, $cancellation);
    }
    /**
     * Download file to an amphp stream, returning it.
     *
     * The returned stream is resumable: it can be serialized, and once unserialized,
     * reading continues from the end of the last chunk read before serialization.
     * The progress callback and cancellation are not preserved by serialization.
     *
     * @param mixed    $messageMedia File to download
     * @param callable $cb           Callback
     * @param int      $offset       Offset where to start downloading
     * @param int      $end          Offset where to end download
     */
    final public function downloadToReturnedStream(mixed $messageMedia, ?callable $cb = null, int $offset = 0, int $end = -1, ?\Amp\Cancellation $cancellation = null): \Amp\ByteStream\ReadableStream&\danog\MadelineProto\ResumableStream
    {
        return $this->wrapper->getAPI()->downloadToReturnedStream($messageMedia, $cb, $offset, $end, $cancellation);
    }
    /**
     * Download file to stream.
     *
     * @param mixed                                               $messageMedia File to download
     * @param mixed|FileCallbackInterface|resource|WritableStream $stream       Stream where to download file
     * @param callable                                            $cb           Callback
     * @param int                                                 $offset       Offset where to start downloading
     * @param int                                                 $end          Offset where to end download
     */
    final public function downloadToStream(mixed $messageMedia, mixed $stream, ?callable $cb = null, int $offset = 0, int $end = -1, ?\Amp\Cancellation $cancellation = null): void
    {
        $this->wrapper->getAPI()->downloadToStream($messageMedia, $stream, $cb, $offset, $end, $cancellation);
    }
    /**
     * Asynchronously write to stdout/browser.
     *
     * @param string $string Message to echo
     */
    final public static function echo(string $string): void
    {
        \danog\MadelineProto\AsyncTools::echo($string);
    }
    /**
     * Get final element of array.
     *
     * @template T
     *
     * @param array<T> $what Array
     *
     * @return T
     *
     * @psalm-pure
     */
    final public static function end(array $what): mixed
    {
        return \danog\MadelineProto\Tools::end($what);
    }
    /**
     * Convert a message and a set of entities to HTML.
     *
     * @param list<MessageEntity|array{_: string, offset: int, length: int}> $entities
     * @param bool                                                           $allowTelegramTags Whether to allow telegram-specific tags like tg-spoiler, tg-emoji, mention links and so on...
     */
    final public static function entitiesToHtml(string $message, array $entities, bool $allowTelegramTags = false): string
    {
        return \danog\MadelineProto\StrTools::entitiesToHtml($message, $entities, $allowTelegramTags);
    }
    /**
     * Export authorization.
     *
     * @return array{0: int, 1: string}
     */
    final public function exportAuthorization(): array
    {
        return $this->wrapper->getAPI()->exportAuthorization();
    }
    /**
     * Export an invite link for a group call.
     *
     * @param bool $canSelfUnmute Whether users joining with this link may speak without asking; admins only.
     */
    final public function exportGroupCallInvite(int $id, bool $canSelfUnmute = false): string
    {
        return $this->wrapper->getAPI()->exportGroupCallInvite($id, $canSelfUnmute);
    }
    /**
     * Extract file info from bot API message.
     *
     * @param array $info Bot API message object
     *
     * @psalm-pure
     */
    final public static function extractBotAPIFile(array $info): ?array
    {
        return \danog\MadelineProto\MTProto::extractBotAPIFile($info);
    }
    /**
     * Extract a message constructor from an Updates constructor.
     */
    final public function extractMessage(array $updates): array
    {
        return $this->wrapper->getAPI()->extractMessage($updates);
    }
    /**
     * Extract a message ID from an Updates constructor.
     */
    final public function extractMessageId(array $updates): int
    {
        return $this->wrapper->getAPI()->extractMessageId($updates);
    }
    /**
     * Extract an update message constructor from an Updates constructor.
     */
    final public function extractMessageUpdate(array $updates): array
    {
        return $this->wrapper->getAPI()->extractMessageUpdate($updates);
    }
    /**
     * Extract Update constructors from an Updates constructor.
     *
     * @return array<array>
     */
    final public function extractUpdates(array $updates): array
    {
        return $this->wrapper->getAPI()->extractUpdates($updates);
    }
    /**
     * Get contents of remote file asynchronously.
     *
     * @param string $url URL
     */
    final public function fileGetContents(string $url, ?\Amp\Cancellation $cancellation = null): string
    {
        return $this->wrapper->getAPI()->fileGetContents($url, $cancellation);
    }
    /**
     * Asynchronously lock a file
     * Resolves with a callbable that MUST eventually be called in order to release the lock.
     *
     * @param  string                                                          $file      File to lock
     * @param  integer                                                         $operation Locking mode
     * @param  float                                                           $polling   Polling interval
     * @param  ?Cancellation                                                   $token     Cancellation token
     * @param  ?Closure                                                        $failureCb Failure callback, called only once if the first locking attempt fails.
     * @return ($token is null ? (Closure(): void) : ((Closure(): void)|null))
     */
    final public static function flock(string $file, int $operation, float $polling = 0.1, ?\Amp\Cancellation $token = null, ?\Closure $failureCb = null): ?\Closure
    {
        return \danog\MadelineProto\AsyncTools::flock($file, $operation, $polling, $token, $failureCb);
    }
    /**
     * When was full info for this chat last cached.
     *
     * @param mixed $id Chat ID
     */
    final public function fullChatLastUpdated(mixed $id): int
    {
        return $this->wrapper->getAPI()->fullChatLastUpdated($id);
    }
    /**
     * Get info about the logged-in user, not cached.
     */
    final public function fullGetSelf(): array|false
    {
        return $this->wrapper->getAPI()->fullGetSelf();
    }
    /**
     * Generate MTProto vector hash.
     *
     * Returns a vector hash.
     *
     * @param array<string|int> $longs IDs
     *
     * @psalm-external-mutation-free
     */
    final public static function genVectorHash(array $longs): string
    {
        return \danog\MadelineProto\Tools::genVectorHash($longs);
    }
    /**
     * Get admin IDs (equal to all user report peers).
     */
    final public function getAdminIds(): array
    {
        return $this->wrapper->getAPI()->getAdminIds();
    }
    /**
     * Get all pending and running calls, indexed by user ID.
     *
     * @return array<int, PrivateCall>
     */
    final public function getAllCalls(): array
    {
        return $this->wrapper->getAPI()->getAllCalls();
    }
    /**
     * Get all group calls (video chats, livestreams and live stories) we're currently tracking, indexed by their ID.
     *
     * @return array<int, AbstractGroupCall>
     */
    final public function getAllGroupCalls(): array
    {
        return $this->wrapper->getAPI()->getAllGroupCalls();
    }
    /**
     * Get full list of MTProto and API methods.
     */
    final public function getAllMethods(): array
    {
        return $this->wrapper->getAPI()->getAllMethods();
    }
    /**
     * Get authorization info.
     *
     * @return \danog\MadelineProto\API::NOT_LOGGED_IN|\danog\MadelineProto\API::WAITING_CODE|\danog\MadelineProto\API::WAITING_SIGNUP|\danog\MadelineProto\API::WAITING_PASSWORD|\danog\MadelineProto\API::LOGGED_IN|API::LOGGED_OUT
     *
     * @psalm-mutation-free
     */
    final public function getAuthorization(): int
    {
        return $this->wrapper->getAPI()->getAuthorization();
    }
    /**
     * Get the progress of a currently running broadcast.
     *
     * Will return null if the broadcast doesn't exist, has already completed or was cancelled.
     *
     * Use updateBroadcastProgress updates to get real-time progress status without polling.
     *
     * @param integer $id Broadcast ID
     *
     * @psalm-mutation-free
     */
    final public function getBroadcastProgress(int $id): ?\danog\MadelineProto\Broadcast\Progress
    {
        return $this->wrapper->getAPI()->getBroadcastProgress($id);
    }
    /**
     * Get cached server-side config.
     */
    final public function getCachedConfig(): array
    {
        return $this->wrapper->getAPI()->getCachedConfig();
    }
    /**
     * Get phone call information.
     *
     * @psalm-mutation-free
     */
    final public function getCall(int $id): ?\danog\MadelineProto\EventHandler\Calls\PrivateCall
    {
        return $this->wrapper->getAPI()->getCall($id);
    }
    /**
     * Get the phone call with the specified user ID.
     *
     * @psalm-mutation-free
     */
    final public function getCallByPeer(int $userId): ?\danog\MadelineProto\EventHandler\Calls\PrivateCall
    {
        return $this->wrapper->getAPI()->getCallByPeer($userId);
    }
    /**
     * Get the media state of the other party of a call, as reported by their client.
     *
     * @psalm-mutation-free
     */
    final public function getCallRemoteMediaState(int $id): ?\danog\MadelineProto\VoIP\MediaState
    {
        return $this->wrapper->getAPI()->getCallRemoteMediaState($id);
    }
    /**
     * Get call state.
     *
     * @psalm-mutation-free
     */
    final public function getCallState(int $id): ?\danog\MadelineProto\VoIP\CallState
    {
        return $this->wrapper->getAPI()->getCallState($id);
    }
    /**
     * Store RSA keys for CDN datacenters.
     */
    final public function getCdnConfig(): void
    {
        $this->wrapper->getAPI()->getCdnConfig();
    }
    /**
     * Get a live end-to-end encrypted conference call this session is in, by its call id.
     *
     * @psalm-mutation-free
     */
    final public function getConferenceCall(int $id): ?\danog\MadelineProto\EventHandler\Calls\ConferenceCall
    {
        return $this->wrapper->getAPI()->getConferenceCall($id);
    }
    /**
     * Get an [end-to-end encrypted conference call »](https://core.telegram.org/api/group-calls#conference-calls)
     * from its [conference link »](https://core.telegram.org/api/links#conference-links) slug, or null if
     * the link is not valid any more.
     */
    final public function getConferenceCallBySlug(string $slug): ?\danog\MadelineProto\EventHandler\Calls\ConferenceCall
    {
        return $this->wrapper->getAPI()->getConferenceCallBySlug($slug);
    }
    /**
     * Get cached (or eventually re-fetch) server-side config.
     *
     * @param array $config Current config
     */
    final public function getConfig(array $config =  [
    ]): array
    {
        return $this->wrapper->getAPI()->getConfig($config);
    }
    /**
     * Get async DNS client.
     *
     * @psalm-mutation-free
     */
    final public function getDNSClient(): \Amp\Dns\DnsResolver
    {
        return $this->wrapper->getAPI()->getDNSClient();
    }
    /**
     * Get diffie-hellman configuration.
     */
    final public function getDhConfig(?\Amp\Cancellation $cancellation = null): array
    {
        return $this->wrapper->getAPI()->getDhConfig($cancellation);
    }
    /**
     * Get dialog IDs.
     *
     * @return list<int>
     */
    final public function getDialogIds(): array
    {
        return $this->wrapper->getAPI()->getDialogIds();
    }
    /**
     * Get download info of file
     * Returns an array with the following structure:.
     *
     * `$info['ext']` - The file extension
     * `$info['name']` - The file name, without the extension
     * `$info['mime']` - The file mime type
     * `$info['size']` - The file size
     *
     * @param mixed $messageMedia File ID
     *
     * @return array{
     *      ext: string,
     *      name: string,
     *      mime: string,
     *      size: int,
     *      InputFileLocation: array,
     *      key_fingerprint?: string,
     *      key?: string,
     *      iv?: string,
     *      thumb_size?: string
     * }
     */
    final public function getDownloadInfo(mixed $messageMedia): array
    {
        return $this->wrapper->getAPI()->getDownloadInfo($messageMedia);
    }
    /**
     * Get download link of media file.
     */
    final public function getDownloadLink(\danog\MadelineProto\EventHandler\Message|\danog\MadelineProto\EventHandler\Media|array|string $media, ?string $scriptUrl = null, ?int $size = null, ?string $name = null, ?string $mime = null): string
    {
        return $this->wrapper->getAPI()->getDownloadLink($media, $scriptUrl, $size, $name, $mime);
    }
    /**
     * Get event handler (or plugin instance).
     *
     * @template T as EventHandler
     *
     * @param class-string<T>|null $class
     *
     * @return T|EventHandlerProxy|__PHP_Incomplete_Class|null
     *
     * @psalm-mutation-free
     */
    final public function getEventHandler(?string $class = null): \danog\MadelineProto\EventHandler|\danog\MadelineProto\Ipc\EventHandlerProxy|\__PHP_Incomplete_Class|null
    {
        return $this->wrapper->getAPI()->getEventHandler($class);
    }
    /**