From 17c186f5b5ab5c515f4b66f969ca1d2e3ea1d72a Mon Sep 17 00:00:00 2001 From: Daniil Gentili Date: Sat, 5 Aug 2023 21:32:33 +0200 Subject: [PATCH] Update baseline --- psalm-baseline.xml | 9167 +++++++++++++++++++++++++++++++++++++++++++- psalm.xml | 2 +- 2 files changed, 9156 insertions(+), 13 deletions(-) diff --git a/psalm-baseline.xml b/psalm-baseline.xml index 0cbda793a..7b3d7219a 100644 --- a/psalm-baseline.xml +++ b/psalm-baseline.xml @@ -1,27 +1,9170 @@ - + + + + $settings + + + __construct($this->session->getSessionDirectoryPath())]]> + + + + + $cb + $started + $started[$k] + + + + getFuture()]]> + + + + + $errors[$t] + $started[$k] + + + $app + $errors[$t] + + + $errors[$t] + + + Logger::$default + + + getMessage + wakeup + + + API + API + API + API + API + API + API + API + API + API + API + API + API + API + API + API + API + API + API + + + + + serializeSession($this)]]> + + + logger + + + + + $eventHandler + + + loop + loop + + + $started + + + $errors[$t] + + + $errors[$t] + + + $errors[$t] + + + getMessage + isInited + setEventHandler + + + + + + + $data + + + + + + $method + $namespace + + + + + + + + + + $params + $signature + reflectionClasses['MTProto']]]> + $type + + + + + isset($arr1['pow']) <=> isset($arr2['pow']))]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + blacklistHard['channels.getMessages']]]> + blacklistHard['messages.getHistory']]]> + blacklistHard['messages.getMessages']]]> + + + + + + + + + + + + + + + + + + + + + + + + + + blacklist[$data['method']]]]> + special[$type]]]> + special[$type]]]> + + + $base + $constructor + $data + $namespace + $namespace + + $param + $param + $param + blacklist]]> + blacklistHard]]> + + + string + string + + + $params + getName() === 'self' ? $this->reflectionClasses['API'] : $type->getName()]]> + + + $base + $base + 'string', + 'bytes' => 'string', + 'waveform' => 'array', + 'int' => 'int', + 'long' => 'int', + 'strlong' => 'int', + 'double' => 'float', + 'float' => 'float', + 'Bool' => 'bool', + 'true' => 'bool', + 'InputMessage' => 'array|int', + 'InputMedia' => '\\danog\\MadelineProto\\EventHandler\\Media|array|string', + 'InputCheckPasswordSRP' => 'string|array', + 'DataJSON' => 'mixed', + 'JSONValue' => 'mixed', + default => $this->special[$type] ?? 'array' + }]]> + 'string', + 'bytes' => 'string', + 'waveform' => 'array', + 'int' => 'int', + 'long' => 'int', + 'strlong' => 'int', + 'double' => 'float', + 'float' => 'float', + 'Bool' => 'bool', + 'true' => 'bool', + 'InputMessage' => 'array|int', + 'InputMedia' => '\\danog\\MadelineProto\\EventHandler\\Media|array|string', + 'InputCheckPasswordSRP' => 'string|array', + 'DataJSON' => 'mixed', + 'JSONValue' => 'mixed', + default => $this->special[$type] ?? 'array' + }]]> + + + + + APIStart + + + + + + + + + + + + + + + + + + + + + + + + + + self::call($a) + self::call($b) + self::call($callable) + self::call($promise) + self::call($promise) + self::timeout($promise, $timeout) + + + $callable instanceof Generator + + + $callable + + + ]]> + + + $v instanceof Generator ? self::consumeGenerator($v) : $v]]> + + + all + any + first + some + wait + + + $lines + $lines + $lines + $lines + $res + $res + + + $failureCb + + + $lines[\count($lines) - 1] + + + $lines[\count($lines) - 1] + + + $result + $yielded + $yielded + $yielded + $yielded + $yielded + $yielded + + + TReturn|TReturnAlt + string + + + $lines[\count($lines) - 1] + + + + + self::timeout($promise, $timeout) + + + \is_callable($callable) + + + + + $updates + + + + + + $id + $updates + + + + + $message + API->methodCallAsyncRead( + isset($message['media']['_']) && + $message['media']['_'] !== 'messageMediaWebPage' + ? 'messages.sendMedia' + : 'messages.sendMessage', + \array_merge($message, ['peer' => $peer]), + ['FloodWaitLimit' => 2*86400] + )]]> + + + + + + $message + + + $id + + + + + broadcasts[$id]]]> + broadcasts[$id]]]> + + + broadcasts[$id]?->cancel()]]> + broadcasts[$id]?->getProgress()]]> + + + + + $value + + + filter->whitelist) && !\in_array($peer, $this->filter->whitelist, true)]]> + + + $e + + + + + getStream()]]> + + + $API + $ctx + $datacenter + $logger + $shared + + + + + + + + $body + $body + + + + + + + + + + + + + + + + + + + + + + + + + $body + $body + $body + $singleMedia + + + + complete + + + refreshNext + refreshNext + + + + + + + + $uri + + - - $MadelineProto->help->getConfig() - + + + + + + $auth_key + $data + $data + $fileName + $fileName + $fp + $new_session + $options + $options + $session + $settings + $settings + $settings + $settings + + + $tdesktop_base_path + $tdesktop_key + $tdesktop_user_base_path + + + pyrogram + tdesktop + tdesktop_decrypt + tdesktop_fopen + tdesktop_fopen_encrypted + tdesktop_md5 + tdesktop_read_bytearray + telethon + zerobias + + + $aes_iv + $aes_key + $auth_key + $data + $data + $data + + $fp + $fp + $info + $info + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main + $main_dc_id + $new_session + $res + $res + $salt + $salt + $salt + + + $settings + $settings + $settings + $settings + + + + self::tdesktop_md5($dataName) + + self::tdesktop_read_bytearray( + self::tdesktop_decrypt($encryptedKey, $passKey), + ) + + + $dcs + + + + + + + + + + + + + + + + + + + + + + + + + + + + $data + $data + $data + $dataName + $dc + + $encryptedInfo + $encryptedKey + $encryptedKey + $f + $info + $key + $length + $main + $main + $res + $salt + $salt + $session + $session + $session + $sessions + + + + self::$tdesktop_key + + + $options + $salt + $salt + + + + + $part_one_md5 + $part_one_md5 + + + $dc + $main_dc_id + + + notFalse + + + break; + + + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + + + $part_two_md5 + $user_id + + + + + $socket instanceof Connection + \is_int($id) + + + + + + + + dclist[$test][$ipv6]]]> + + + + + + + + + + + + dclist[$test][$ipv6]]]> + dclist[$test][$ipv6]]]> + dclist[$test][$ipv6]]]> + dclist[$test][$ipv6]]]> + dclist[$test][$ipv6][$dc_number]]]> + dclist[$test][$ipv6][$dc_number]]]> + dclist[$test][$ipv6][$dc_number]['secret']]]> + dclist[$test][$ipv6][$dc_number]['tcpo_only']]]> + dclist[$test][$ipv6][$id]]]> + + + + + + $changed[$id] + $changed[$id] + dclist[$test][$ipv6]]]> + dclist[$test][$ipv6][$id]]]> + sockets[$id]]]> + + + $address + + + + $combo[\count($combo) - 2][1] + $data + $data + $dc + $dcs + $extra + $id + $ipv6 + $only + $port + $port + $subdomain + $subdomain + + + bool + + + $address + $address + $address + $port + $port + $port + $port + $port + $subdomain + $subdomain + $subdomain + $subdomain + + + sockets]]> + + + dclist[$test][$ipv6][$dc]['cdn'] ?? false]]> + dclist[$test][$ipv6][$dc]['cdn'] ?? false]]> + + + $default[2] + $default[2] + + + $dohWrapper + + + $socket instanceof DataCenterConnection + + settings->getTransport()]]> + \is_int($key) + + + + + $API + $connectionsPromise + $ctx + $datacenter + + + $aes_iv + $aes_key + $exported_authorization + $message_data + + + $exported_authorization + $message_data + $res + + + bind + + + hasTempAuthKey() + && $authorized_socket->hasPermAuthKey() + && $authorized_socket->isAuthorized() + && $this->API->authorized === \danog\MadelineProto\API::LOGGED_IN]]> + + + permAuthKey =& $this->API->datacenter->getDataCenterConnection($dc)->permAuthKey]]> + + + + + $value + + + getCache + + + $newValues[$key] + + + + + ]]> + + + + + $promises[$property] + + + $property + $result + $type + + + $result + + + + + $config + $config + withDatabase(null)]]> + getIdleTimeout()]]> + getMaxConnections()]]> + + + query("SHOW VARIABLES LIKE 'max_connections'")->fetchRow()['Value']]]> + + + + + $config + $config + withDatabase(null)]]> + getIdleTimeout()]]> + getMaxConnections()]]> + - - getName + + $previous + $settings + $settings + $settings + + + $instance + + + $v + $value + $value + + + $v]]> + \json_decode($value, true, 256, JSON_THROW_ON_ERROR)]]> + + + $dbSettings + $dbSettings + $dbSettings + $dbSettings + $dbSettings + $dbSettings + $dbSettings + $dbSettings + $deserializer + $deserializer + $deserializer + $deserializer + $deserializer + $deserializer + $deserializer + $deserializer + $serializer + $serializer + $serializer + $serializer + $serializer + $serializer + $serializer + $serializer + $table + $table + $table + $table + $table + $table + $table + $table + + + $key + $value + + + $value + + + static + + + $old + + + setSettings + + new static() + - + MemoryArray MemoryArray + + $array + $flags + + + $flags | self::STD_PROP_LIST + + + $flags + + + $settings + + + + + dbSettings]]> + + + $stmt + + + $pdo + $pdo + + + $value + + + $value + + + + + $value + + + + + $v + $v + $v + $v + $v + $v + $v + $value + + + \igbinary_unserialize(\hex2bin($v))]]> + \unserialize(\hex2bin($v))]]> + \json_decode(\hex2bin($value), true, 256, JSON_THROW_ON_ERROR)]]> + + + $v + $v + $v + $v + $value + + + + + dbSettings]]> + + + $v + $v + $v + $v + $v + $value + + + $v]]> + \json_decode($value, true, 256, JSON_THROW_ON_ERROR)]]> + + + $v + $value + + + + + dbSettings]]> + + + $db + + + serializer)($value)]]> + + + $key + $key + $key + $key + $key + $key + $key + + + $value + + + db->get($key)]]> + $value + + + + + $stmt + + + $db + $db + $db + $db + $db + $db + + + + + + $value + + + $value + + + fetchRow()['count']]]> + + + + + $host + $host + $host + $host + $port + $port + $scheme + $scheme + + + $host[0] + + + $builtUri + $uri + + + + + $extra + + + $orig[1][0] === BufferedRawStream::class + + + + + $any + $td + $types + + + $name + $otype + settings['description']]]> + settings['output_dir']]]> + settings['output_dir']]]> + settings['output_dir']]]> + templates[$constructor]]]> + templates[$name]]]> + templates[$type]]]> + templates['Type']]]> + types]]> + + + + + + + + + + + + $data + $data + $keys + $name + $otype + + + + + settings['template']]]> + templates['types-index']]]> + + + $tdDescriptions + DocsBuilder + DocsBuilder + DocsBuilder + + + + + $constructor + $description + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + + + $ptype + $ptype + $ptype + types[$php_type]['constructors']]]> + $type + + + + + + + + + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + + + + + + + + + + + + + + + + + + + + + + + + + + + + TL->getConstructors()->findByType(\str_replace('%', '', $param[$type_or_subtype]))['predicate']]]> + TL->getConstructors()->findByType(\str_replace('%', '', $ptype))['predicate']]]> + TL->getDescriptionsRef()['constructors'][$constructor]['description']]]> + TL->getDescriptionsRef()['constructors'][$constructor]['description']]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + types[$php_type]]]> + types[$php_type]['constructors']]]> + + + + + + + + + + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + + + + + + + TL->getDescriptionsRef()['constructors'][$constructor]]]> + TL->getDescriptionsRef()['constructors'][$constructor]]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + types[$php_type]]]> + types[$php_type]]]> + types[$php_type]['constructors']]]> + + + $got[$id] + $got[$id] + TL->getConstructors()->by_id[$id]]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + + + $constructor + $data + $description + $id + $param + $param + $param[$type_or_subtype] + $ptype + $ptype + TL->getDescriptionsRef()['constructors'][$constructor]['description']]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + $type + + + + $param[$type_or_subtype] + + + + + + + + + + + TL->getDescriptionsRef()['constructors'][$constructor]['description']]]> + TL->getDescriptionsRef()['constructors'][$constructor]['params'][$param['name']]]]> + any]]> + + + $ppptype + $ppptype + $predicate + $pwr_params + $pwr_params + $pwr_params + $pwr_params + + + + + $bots + + $description + $human_ptype + $human_ptype + $method + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + + + + + tdDescriptions['methods'][$method]['description'] ?? '']]> + types[$php_type]['methods']]]> + + + + + + + + + + + + + + + + + + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + tdDescriptions['methods'][$method]]]> + tdDescriptions['methods'][$method]]]> + tdDescriptions['methods'][$method]]]> + tdDescriptions['methods'][$method]['description']]]> + tdDescriptions['methods'][$method]['description']]]> + tdDescriptions['methods'][$method]['description']]]> + tdDescriptions['methods'][$method]['params']]]> + tdDescriptions['methods'][$method]['params'][$param['name']]]]> + types[$php_type]]]> + types[$php_type]['methods']]]> + + + + + + + + + $param[$type_or_subtype] + $param[$type_or_subtype] + $param[$type_or_subtype] + + + + + + + + + + tdDescriptions['methods'][$method]]]> + tdDescriptions['methods'][$method]]]> + tdDescriptions['methods'][$method]['params'][$param['name']]]]> + types[$php_type]]]> + types[$php_type]]]> + types[$php_type]['methods']]]> + + + + $new[$method] + $new[$method] + + tdDescriptions['methods'][$method]['params'][$param['name']]]]> + tdDescriptions['methods'][$method]['params'][$param['name']]]]> + tdDescriptions['methods'][$method]['params'][$param['name']]]]> + + + $bots + $code + $code + $data + $description + $error + $error + $errors + $human_ptype + $id + $id + $id + $id + $method + $method + $param + $param + $ppptype + $ppptype + $ptype + $suberrors + $suberrors + + + + + + + + + + + + + $ppptype + $ptype + $ptype + $ptype + $ptype + any]]> + tdDescriptions['methods'][$method]['description']]]> + tdDescriptions['methods'][$method]['params'][$param['name']]]]> + + + + + $id + $json_params + $json_params + $json_params + $ppptype + $ppptype + $pwr_params + $pwr_params + $pwr_params + + + + + $class + + + getReportPeers())]]> + getReportPeers())]]> + + + $newHandlers + $pluginsTemp + + self::$checkedPaths[$p] + + + $closure + + + + + + $newHandlers + $newMethods + + + $pluginsTemp [] + + + + + $methods[$update] + $methods[$update] + $methods[$update] + + + $constructor + $constructor + $method + $methods[$update][] + $onAny + $plugin + $pluginsNew[$class] + $r + $r + $r + $r + $update + [$newMethods, $newHandlers] + self::$checkedPaths[$p] + + + + $recurse($p) + + + bool + + + internalStart + isPluginEnabled + + + $closure($loop) ?? false + $closure($loop) ?? false + + + periodicLoops]]> + ]]> + + + wrapper->getAPI()]]> + + + getParameters()[0]->getType()]]> + + + self::$pluginCache + + + \array_values + + + require $file + + + new $class + + + $handler + $pluginsTemp + $r + + + + + replyCache]]> + replyCache]]> + + + $messages[0] + + + $messages[0] + + + + + + + + + + + getClient()->methodCallAsyncRead( + API::isSupergroup($this->chatId) ? 'channels.getMessages' : 'messages.getMessages', + [ + 'channel' => $this->chatId, + 'id' => [['_' => 'inputMessageReplyTo', 'id' => $this->id]] + ] + )['messages']]]> + + + $messages + $replyTo + chatId]]> + date]]> + id]]> + mentioned]]> + out]]> + replyToMsgId]]> + replyToMsgId]]> + replyToMsgId]]> + replyToScheduled]]> + senderId]]> + silent]]> + threadId]]> + threadId]]> + topicId]]> + topicId]]> + ttlPeriod]]> + + + $replyCache + + + + + chatInstance]]> + queryId]]> + userId]]> + + + bool + + + getClient()->methodCallAsyncRead( + 'messages.setBotCallbackAnswer', + [ + 'query_id' => $this->queryId, + 'message' => $message, + 'alert' => $alert, + 'url' => $url, + 'cache_time' => $cacheTime, + ], + )]]> + + + + + $adminIds + + + + + $peerResolved + + + + + $peersResolved + + + + + $peerResolved + + + + + $matches + $matches + + + \preg_match + + + + + $peerResolved + + + + + + + + + + + + + + + + + + creationDate]]> + spoiler]]> + ttl]]> + + + botApiFileId]]> + botApiFileUniqueId]]> + + + $thumbs + $videoThumbs + + + + + duration]]> + + + AbstractAudio + AbstractAudio + + + + + emoji]]> + stickerset]]> + + + AbstractSticker + AbstractSticker + + + + + duration]]> + height]]> + supportsStreaming]]> + width]]> + + + AbstractVideo + AbstractVideo + + + + + + + + + AnimatedSticker + AnimatedSticker + + + + + performer]]> + title]]> + + + Audio + Audio + + + + + + + + + free]]> + textColor]]> + + + CustomEmoji + CustomEmoji + + + + + Document + Document + + + + + + $t + + + height]]> + width]]> + $t]]]> + + + DocumentPhoto + DocumentPhoto + + + + + + $t + + + $t]]]> + + + Gif + Gif + + + + + + + + + + + + + + + $coords + x]]> + y]]> + zoom]]> + + + MaskSticker + MaskSticker + + + + + + + + hasStickers]]> + + + Photo + Photo + + + + + RoundVideo + RoundVideo + + + + + + + + + StaticSticker + StaticSticker + + + + + Sticker + Sticker + + + + + + $t + + + $t]]]> + + + Video + Video + + + + + + + + + duration]]> + + + VideoSticker + VideoSticker + + + + + waveform]]> + + + Voice + Voice + + + + + entities]]> + entities]]> + + + getClient()->wrapMessage($this->getClient()->extractMessage($result))]]> + + + + + + + + + + $result + $result + $result + message]]> + message]]> + message]]> + message]]> + protected]]> + + + + + + + + + + + + + + + + $result[0] + + message[0]]]> + message[0]]]> + + + $fwdFrom + $r + $result + $result + $result + $result + editDate]]> + entities]]> + fromScheduled]]> + imported]]> + message]]> + protected]]> + psaType]]> + viaBotId]]> + + + string + + + reactions]]> + + + + + + Message + + + getClient()->wrapMessage($this->getClient()->extractMessage($result))]]> + + + $html + $htmlTelegram + Message + + + wrapMedia($rawMessage['media'], $this->protected) + : null]]> + + + + + + signature]]> + views]]> + + + ChannelMessage + ChannelMessage + ChannelMessage + + + + + GroupMessage + GroupMessage + GroupMessage + + + + + PrivateMessage + PrivateMessage + PrivateMessage + + + + + DialogCreated + + + + + DialogMemberLeft + + + + + DialogMembersJoined + + + + + DialogMessagePinned + + + + + DialogPhotoChanged + + + + + DialogTitleChanged + + + + + + + + getName()]]]> + + + + + $result + + + $result + messageId]]> + + + Message + + + getIdInternal($rawCallback['peer'])]]> + + + + + gameShortName]]> + + + + + + + + + + + + + + + + + + + getName()]]]> + + + + + severe ? 'static_analysis_severe' : 'static_analysis_minor']]]> + + + + + $code + $errfile + $errline + $errno + $errstr + $file + $line + $message + + + $code + + $errstr + $errstr + $errstr + $errstr + $message + $message + file]]> + file]]> + + + + + + + + + + + + + + + + + file]]> + line]]> + + + line]]> + + + $maps + + + + + __invoke + + + + + $id + MADELINE_PHAR_GLOB + MADELINE_PHAR_VERSION + MADELINE_PHP + MADELINE_PHP + MADELINE_RELEASE_URL + + + self::$map + self::$map ??= new WeakMap + + + + + \danog\MadelineProto\AsyncTools::after($a, $b) + \danog\MadelineProto\AsyncTools::all($promises) + \danog\MadelineProto\AsyncTools::any($promises) + \danog\MadelineProto\AsyncTools::call($promise) + \danog\MadelineProto\AsyncTools::first($promises) + \danog\MadelineProto\AsyncTools::some($promises) + \danog\MadelineProto\AsyncTools::timeout($promise, $timeout) + \danog\MadelineProto\AsyncTools::timeoutWithDefault($promise, $timeout, $default) + \danog\MadelineProto\AsyncTools::wait($promise) + loop + loop + + + wrapper->getAPI()->getDownloadInfo($messageMedia)]]> + wrapper->getAPI()->getEventHandler($class)]]> + + + T|EventHandlerProxy|__PHP_Incomplete_Class|null + array{ + * ext: string, + * name: string, + * mime: string, + * size: int, + * InputFileLocation: array, + * key_fingeprint?: string, + * key?: string, + * iv?: string, + * thumb_size?: string + * } + + + $data + + + MTProtoToTd + MTProtoToTdcli + all + any + completeCall + completePhoneLogin + confirmCall + downloadToCallable + downloadToDir + downloadToStream + end + first + loop + phoneLogin + requestCall + requestSecretChat + some + start + tdToTdcli + upload + uploadEncrypted + uploadFromCallable + uploadFromStream + uploadFromTgfile + uploadFromUrl + wait + + + string|false + + + wrapper->getAPI()->downloadToFile($messageMedia, $file, $cb)]]> + wrapper->getAPI()->downloadToFile($messageMedia, $file, $cb)]]> + + + account ??= new \danog\MadelineProto\Namespace\AbstractAPI('account')]]> + auth ??= new \danog\MadelineProto\Namespace\AbstractAPI('auth')]]> + bots ??= new \danog\MadelineProto\Namespace\AbstractAPI('bots')]]> + channels ??= new \danog\MadelineProto\Namespace\AbstractAPI('channels')]]> + chatlists ??= new \danog\MadelineProto\Namespace\AbstractAPI('chatlists')]]> + contacts ??= new \danog\MadelineProto\Namespace\AbstractAPI('contacts')]]> + folders ??= new \danog\MadelineProto\Namespace\AbstractAPI('folders')]]> + help ??= new \danog\MadelineProto\Namespace\AbstractAPI('help')]]> + langpack ??= new \danog\MadelineProto\Namespace\AbstractAPI('langpack')]]> + messages ??= new \danog\MadelineProto\Namespace\AbstractAPI('messages')]]> + payments ??= new \danog\MadelineProto\Namespace\AbstractAPI('payments')]]> + phone ??= new \danog\MadelineProto\Namespace\AbstractAPI('phone')]]> + photos ??= new \danog\MadelineProto\Namespace\AbstractAPI('photos')]]> + stats ??= new \danog\MadelineProto\Namespace\AbstractAPI('stats')]]> + stickers ??= new \danog\MadelineProto\Namespace\AbstractAPI('stickers')]]> + stories ??= new \danog\MadelineProto\Namespace\AbstractAPI('stories')]]> + updates ??= new \danog\MadelineProto\Namespace\AbstractAPI('updates')]]> + upload ??= new \danog\MadelineProto\Namespace\AbstractAPI('upload')]]> + users ??= new \danog\MadelineProto\Namespace\AbstractAPI('users')]]> + + + $callback + + + MTProtoToBotAPI + MTProtoToTd + MTProtoToTdcli + acceptCall + acceptSecretChat + botAPIToMTProto + botLogin + broadcastCustom + broadcastForwardMessages + broadcastMessages + callStatus + cancelBroadcast + complete2faLogin + completeCall + completePhoneLogin + completeSignup + confirmCall + discardCall + discardSecretChat + downloadToBrowser + downloadToCallable + downloadToDir + downloadToFile + downloadToResponse + downloadToStream + exportAuthorization + extractMessage + extractMessageId + extractMessageUpdate + extractUpdates + fileGetContents + fullChatLastUpdated + fullGetSelf + getAdminIds + getAllMethods + getAuthorization + getBroadcastProgress + getCachedConfig + getCall + getCdnConfig + getConfig + getDNSClient + getDhConfig + getDialogIds + getDialogs + getDownloadInfo + getDownloadLink + getEventHandler + getFileInfo + getFullDialogs + getFullInfo + getHTTPClient + getHint + getId + getInfo + getLogger + getMethodNamespaces + getMethodsNamespaced + getPlugin + getPropicInfo + getPsrLogger + getPwrChat + getSecretChat + getSelf + getSessionName + getSettings + getSponsoredMessages + getTL + getType + getUpdates + getWebMessage + hasAdmins + hasEventHandler + hasPlugin + hasReportPeers + hasSecretChat + importAuthorization + initSelfRestart + isForum + isIpc + isIpcWorker + isPremium + isSelfBot + isSelfUser + logger + loop + peerIsset + phoneLogin + processDownloadServerPing + qrLogin + refreshFullPeerCache + refreshPeerCache + rekey + report + reportMemoryProfile + requestCall + requestSecretChat + resetUpdateState + restart + secretChatStatus + sendCustomEvent + sendDocument + sendMessage + sendMessageToAdmins + sendPhoto + setNoop + setReportPeers + setWebhook + setupLogger + start + stop + subscribeToUpdates + tdToMTProto + tdToTdcli + tdcliToTd + unsetEventHandler + update2fa + updateSettings + upload + uploadEncrypted + uploadFromCallable + uploadFromStream + uploadFromTgfile + uploadFromUrl + viewSponsoredMessage + wrapMedia + wrapMessage + wrapUpdate + + + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + setWrapper + + + + + $class + + + downloadToCallable + downloadToDir + downloadToFile + loop + methodCallAsyncRead + uploadFromCallable + uploadFromTgfile + uploadFromUrl + + + __call(...)]]> + + + + + + + + + $callable + $callable + $dir + $file + $media + $media + $r + $r + $r + $url + + + Client|MTProto + + + self::$instances[$session] ?? MTProto::giveInstanceBySession($session) + self::$instances[$session] ?? MTProto::giveInstanceBySession($session) + + + + + getException()]]> + + + $id + $payload + + + requests[$id]]]> + + + $payload + [$id, $payload] + + + logger + + + + + + $logger + $server + + + $promise + + + + + $previous + + + type($this->message, $this->code, $previous)]]> + + + tlTrace]]> + + + code]]> + + + + + API]]> + + + API ??= Client::giveInstanceBySession($this->session)]]> + API ??= Client::giveInstanceBySession($this->session)]]> + + + + + exception ? $this->exception->getException() : null]]> + + + ?Throwable + + + + + $value + + + $value + + + + + string + + + \MADELINE_PHP + + + + + + + + + + + $address + + + (int) $port + + + + + + $session + + + $session + + + + $arguments + $arguments + $arguments + + + + + + + + + exit(1); + exit(1); + exit(1); + + + include $autoloadPath + + + + + $payload + $payload[1] + $result + + + disconnect + + + $callback + $server + $settings + + + $payload === self::SHUTDOWN + $payload === self::SHUTDOWN + + + + + unwrap + + + ServerCallback + ServerCallback + + + + + $args + + + $this->__call($id, $args)]]> + + + $data + + + copy + unwrap + + + callbacks[$payload[0]]]]> + + + remoteId]]> + $payload + $result + + + callbacks]]> + + + $data + Wrapper + Wrapper + + + new $class($this, $ids) + + + callbackIds[] = &$callback]]> + callbackIds[] = &$callback]]> + + + $payload + + + + + bool + string + + + __call('isRequested')]]> + __call('unsubscribe', [$callback])]]> + + + + + bool + + + + + IteratorAggregate + + + ?string + bool + + + __call('isReadable')]]> + __call('read')]]> + + + + + int + + + + + bool + + + __call('isWritable')]]> + + + + + getEventHandler()::class]]> + + + + + $param + colors[$level]]]> + + + $optional + $optional + $optional + $optional + $optional + $optional + $optional + $optional + getResource()]]> + mode === self::FILE_LOGGER + ? $this->optional + : Magic::$script_cwd.DIRECTORY_SEPARATOR.'MadelineProto.log']]> + optional]]> + optional]]> + stdout->getResource()]]> + + + $optional + $optional + $optional + $optional + $optional + $optional + $optional + optional]]> + optional]]> + + + $optional + + + optional, [$param, $level])]]> + + + + + + + $colors + $stdout + + + colors]]> + colors]]> + colors]]> + colors]]> + colors]]> + colors]]> + colors]]> + colors]]> + + + + + $message_id + $message_id + + + + + + + connection->new_outgoing[$message_id]]]> + connection->outgoing_messages[$message_id]]]> + connection->outgoing_messages[$message_id]]]> + + + $message_id + $message_id + $reply[] + $reply[] + $reply[] + + + getMsgId()]]> + + + getSent()]]> + getSent()]]> + + + API->settings]]> + + + getRpc + + + CheckLoop + CheckLoop + CheckLoop + CheckLoop + CheckLoop + + + API]]> + + + $message_id + $reply + + + + + CleanupLoop + CleanupLoop + CleanupLoop + CleanupLoop + CleanupLoop + + + connection->msgIdHandler?->cleanup()]]> + + + connection->msgIdHandler]]> + + + + + HttpWaitLoop + + + + + getSettings + + + PingLoop + PingLoop + PingLoop + PingLoop + + + shared]]> + + + + + $aes_iv + $aes_key + $deserialized + $message_data_length + $message_length + $seq_no + + + $deserialized + $message_data_length + $message_length + $seq_no + + + $message_data_length + $message_data_length + $message_data_length + + + bufferRead($payload_length)]]> + bufferRead(4)]]> + bufferRead(4)]]> + bufferRead(8)]]> + $message_data + $message_data + $message_key + + + $payload_length + $payload_length + + + getReadBuffer + + + ReadLoop + + + + + + + $aes_iv + $aes_key + $body + $body + $message_data + connection->call_queue[$queueId]]]> + connection->call_queue[$queueId]]]> + connection->call_queue[$queueId]]]> + + + connection->call_queue[$queueId][$key]]]> + + + connection->call_queue[$queueId][$message_id]]]> + + + connection->call_queue[$queueId][$key]]]> + + + + + $body + $body + $message_data + $message_data + $seq_no + $seq_no + + + $message_data + + + + getSerializedBody()]]> + getSerializedBody()]]> + + + connection->call_queue]]> + connection->call_queue]]> + + + getSerializedBody()]]> + connection->session_id]]> + + + getWriteBuffer + getWriteBuffer + + + $messages[0] + + + WriteLoop + + + shared->isHttp() && empty($this->connection->pendingOutgoing)]]> + + + $MTmessage + + + + + $callable()]]> + + + $callable()]]> + + + + + $msg + + + $messages + $update + + + feed + feedSingle + + + $channelId + $channelId + $message + $update + $update + $update + + + + + + + + + + + + + + feedSingle($update)]]]> + API->feeders[$channelId]]]> + + + API->feeders[$channelId]]]> + + + $channelId + $channelId + $channelId + $computed + $message + $mid + $pts_count + state]]> + $update + $update + $update + + + + $pts_count + + + + + + + $state + $updater + FeedLoop + + + $from + $parsedUpdates + $updates + + + + + $update + + + $update + + + SecretFeedLoop + + + $updates + + + + + + $seq_end + $seq_start + $update + + + + + + + + + $options + $seq_end + $seq_start + pendingWakeups]]> + state]]> + $update + + + feeder->feed($updates['updates'])]]> + + + + checkSeq + feed + + + $options + $updates + + + + + API->feeders[$channelId]]]> + + + $difference + $difference + $difference + $difference + $difference + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + API->authorization['user']['bot']]]> + + + + + + + API->feeders[$channelId]]]> + + + $channelId + $difference + $difference + + + $encrypted + $encrypted + $request_pts + $result + $result + $result + $result + $result + $state + $timeout + + + ?float + + + date + pts + pts + pts + pts + pts + qts + qts + qts + update + update + update + update + update + update + update + + + + + $request_pts + $result + $result + pts()]]> + pts()]]> + pts() + 1]]> + feeder->feed($difference['other_updates'])]]> + feeder->feed($difference['other_updates'])]]> + feeder->feed($difference['other_updates'])]]> + + + $timeout + $timeout + + + date + pts + pts + pts + pts + pts + qts + qts + qts + update + update + update + update + update + update + update + + + API->authorization['user']]]> + API->authorization['user']['bot']]]> + + + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + $difference + + + $feeder + UpdateLoop + + + API->feeders[$channelId]?->resume()]]> + + + + + datacenter)]]> + TL)]]> + settings)]]> + settings)]]> + dcList, $this->settings->getConnection())]]> + + + $callbacks + $callbacks + + + getInputConstructor(...), + ), + \array_fill_keys( + [ + 'User', + 'Chat', + 'Peer', + 'InputDialogPeer', + 'InputNotifyPeer', + ], + $this->getInfo(...), + ), + \array_fill_keys( + [ + 'InputMedia', + 'InputDocument', + 'InputPhoto', + ], + $this->getFileInfo(...), + ), + [ + 'InputFileLocation' => $this->getDownloadInfo(...), + 'InputPeer' => $this->getInputPeer(...), + 'InputCheckPasswordSRP' => function (string $password): array { + return (new PasswordCalculator($this->methodCallAsyncRead('account.getPassword', [])))->getCheckPassword($password); + }, + ], + )]]> + + + array + + + serializeSession + + + + + $key + $key + $key + $key + + + $options + TL]]> + TL]]> + datacenter->currentDatacenter]]> + methodCallAsyncRead('account.getPassword', [])]]> + methodCallAsyncRead('phone.getCallConfig', [])]]> + settings]]> + settings->getIpc()]]> + settings->getSchema()]]> + settings->getSerialization()->applyChanges()->getInterval()]]> + $username + + + + + + + + $callbacks + $callbacks + $id + referenceDatabase->init(...)]]> + + + + + + + + + + + + + + + + + + + authorization['user']['bot']]]> + authorization['user']['bot']]]> + authorization['user']['bot']]]> + authorization['user']['id']]]> + secret_chats[$chat]['InputEncryptedChat']]]> + $username + + + + + methodCallAsyncRead('help.getCdnConfig', [], ['datacenter' => $this->authorized_dc]))['public_keys']]]> + methodCallAsyncRead('users.getUsers', ['id' => [['_' => 'inputUserSelf']]]))[0]]]> + + + $new[$test][$ipv6][$id] + + + $callbacks [] + $chat + $chat + $controller + $curkey + $data + $dc + $file + $id + $id + $id + $id + $key + $key + $key + $lock + $method + $methods[] + $nearest_dc + $new[$test][$ipv6][$id] + $new_dc + $options + $selfBot + callCheckerLoop]]> + config]]> + configLoop]]> + datacenter]]> + phoneConfigLoop]]> + referenceDatabase]]> + reportMutex]]> + serializeLoop]]> + $value + Lang::$current_lang + $username]]]> + + + array + array|false + bool + bool + + + acquire + applyChanges + applyChanges + applyChanges + applyChanges + discard + getAppInfo + getAuth + getCallState + getConnection + getConnection + getConnection + getDataCenterConnection + getDb + getDb + getDb + getDb + getEnableFileReferenceDb + getEnableMinDb + getInterval + getIpc + getIpc + getIpc + getLogger + getRSAKeys + getSchema + getSchema + getSchema + getSchema + getSchema + getSerialization + getSerialization + getTestRSAKeys + hasApiInfo + hasChanged + hasChanged + hasChanged + hasChanged + hasChanged + hasChanged + hasChanged + hasTempAuthKey + init + init + merge + needsUpgrade + needsUpgrade + needsUpgrade + release + resume + setMadeline + setMadeline + setSettings + start + start + start + start + start + stop + + + $id + + + + datacenter]]> + datacenter]]> + + + datacenter->currentDatacenter]]> + + + authorization['user'] ?? false]]> + authorization['user'] ?? false]]> + authorization['user']['bot']]]> + authorization['user']['bot']]]> + config]]> + config]]> + getSelf()['premium']]]> + + + cdn_rsa_keys]]> + ]]> + + + authorization['user']['bot']]]> + + + channels_state->get()]]> + channels_state->get()]]> + channels_state->get()]]> + channels_state->get()]]> + + + $path + + + getSelf()['bot']]]> + getSelf()['premium']]]> + + + $path + + + authorization['hint']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']['bot']]]> + authorization['user']['bot']]]> + authorization['user']['bot']]]> + authorization['user']['id']]]> + + + logger + start + start + + + $channelParticipants + $chats + $full_chats + $logger + $minDatabase + $session + $snitch + $usernames + $wrapper + MTProto + + + sanitizeReportPeers($userOrId)]]> + + + chats]]> + chats]]> + + + minDatabase?->sync()]]> + wrapper) && $this->isInited()]]> + + + authorized === API::LOGGED_IN && \is_int($dc_id)]]> + datacenter]]> + \is_int($dc_id) + datacenter)]]> + + + minDatabase]]> + + + settings->getAppInfo()->getLangCode()]]]> + + + $chat + $data + + + \memprof_dump_pprof + + + $callbacks + Lang::$current_lang + + + + + + + + + + + + + + + content['_']]]]> + + + int + string + + + content['_']]]> + content[self::RESPONSE_ID_MAP[$this->content['_']]]]]> + + + + + getBody + + + new DeferredFuture + + + state |= self::STATE_ACKED]]> + state |= self::STATE_REPLIED]]> + state |= self::STATE_SENT]]> + + + sent]]> + + + + + + + + authKey]]> + + + + + + + + + authKey]]> + + + authorized + + + {$key} =& $bound->{$key}]]> + + + + + ack_queue]]> + new_outgoing]]> + + + getSent()]]> + getSent()]]> + getSent()]]> + + + MTProtoOutgoingMessage + MTProtoOutgoingMessage + + + + + + $data + $encrypted_answer + $p + $p_q_inner_data + $p_q_inner_data + $pq_bytes + $q + + $server_nonce + time_delta]]> + + + + + + + + + + + + + + + + + + + + + + + + $ResPQ + $Set_client_DH_params_answer + $data + $encrypted_answer + $encrypted_data + $p + $p + $p_q_inner_data + $pq_bytes + $q + $q + $server_DH_inner_data + $server_dh_params + $server_nonce + $server_time + time_delta]]> + + + encrypt + + + $data + $p + $p + $p + $p*$q + $p_q_inner_data + $q + $q + $server_nonce + $server_nonce + $server_nonce + $server_time + + + fp]]> + + + expires + + + break; + + + string + + + + + $f->await()]]> + + + methodCallAsyncRead + + + + + + + + + API->parseMode($args)['message']]]> + + + + + + outgoing_messages[$message_id]]]> + outgoing_messages[$message_id]]]> + + + + + + $message_id + $methodInfo + $single_args + + + WrappedFuture + + + outgoing_messages[$message_id] ?? $message_id]]> + + + resume + resume + + + MTProtoOutgoingMessage + MTProtoOutgoingMessage + + + $promises + + + + + getMaxId + + + + + + + + $msg_id + + + + + + + incoming_messages[$content['answer_msg_id']]]]> + incoming_messages[$content['answer_msg_id']]]]> + incoming_messages[$msg_id]]]> + incoming_messages[$msg_id]]]> + outgoing_messages[$content['msg_id']]]]> + outgoing_messages[$msg_id]]]> + + + $key + $msg_id + $msg_id + $msg_id + $msg_id + $shifted + + + $msg_id + $msg_id + + + + + $e]]> + + + + getContent()['_']]]> + read()['msg_ids']]]> + read()['server_salt']]]> + + + + + + $msg_id + $referencedMsgId + $response + $response + + + + + + + + + + + + + + + + + + + + + + + + $current_msg_id + $current_msg_id + $current_msg_id + $expecting_msg_id + + + + + + + + + + + + + + + + API->getTL()->getConstructors()->findByPredicate($message->getContent()['_'])['type']]]> + API->getTL()->getConstructors()->findByPredicate($response['_'])['type']]]> + + + incoming_messages[$message['msg_id']]]]> + incoming_messages[$referencedMsgId]]]> + new_incoming[$message['msg_id']]]]> + + + + + $constructor + $message + $msg_id + $referencedMsgId + $response + $response_type + + + $response_type + API->authorization['user']['phone']]]> + API->authorization['user']['phone']]]> + + + $response + \time() + $seconds + + + $msgId + $msgId + getMsgId()]]> + getMsgId()]]> + getMsgId()]]> + + + getMsgId()]]> + + + resume + + + API->authorized_dc == $this->datacenter && $this->API->authorized === \danog\MadelineProto\API::LOGGED_IN]]> + + + MTProtoIncomingMessage + MTProtoOutgoingMessage + + + + + $contentRelated + $contentRelated + + + generateInSeqNo + generateOutSeqNo + + + $seq_no + + + $seq_no + + + getSeqNo()]]> + + + + + $msgIdHandler + + + getSent()]]> + + + + + + + + + + + + + + + + + $dh_config + dh_config]]> + + + array + + + + + methodCallAsyncRead + methodCallAsyncWrite + + + datacenter->currentDatacenter]]> + datacenter->currentDatacenter]]> + + + + + $channel + + + $state + + + states]]> + + + syncLoading + + + + + + + + + + + self::$checkedAutoload[$autoloadPath] + self::$checkedAutoload[$autoloadPath] + self::$checkedAutoload[$autoloadPath] + + + $autoloadPath + $autoloadPath + $f + + + string + + + + + + + getSelf()['id']]]> + getSelf()['id']]]> + + + $media + + + extractBotAPIFile($this->MTProtoToBotAPI($media))['file_id']]]> + + + $name + + + + + + + + + + + + + + static function (int $part_num) use ($size, $file_id, $part_total_num, $part_size, $callable, $ige) { + + + $data + $media + + + downloadToCallable + downloadToDir + genAllFile + uploadFromCallable + uploadFromTgfile + uploadFromUrl + + + + + $bytes + $cur * 100 / $count + $cur * 100 / $part_total_num + $datacenter + $datacenter + $file + $info + $media + $media + + + + $messageMedia + $messageMedia + $messageMedia + + + + + + + + + + + + + + + + + + + + $old_dc + $resPromises + + + + + $speed + $speed + methodCallAsyncRead('upload.getCdnFileHashes', ['file_token' => $file, 'offset' => $offset], ['datacenter' => $datacenter])]]> + methodCallAsyncRead('upload.reuploadCdnFile', ['file_token' => $messageMedia['file_token'], 'request_token' => $res['request_token']], ['heavy' => true, 'datacenter' => $old_dc])]]> + $time + $time + $url + ++$datacenter + + + downloadToCallable(...)]]> + methodCallAsyncWrite(...)]]> + uploadFromCallable(...)]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TL->getConstructors()->findByPredicate($media['_'])['type']]]> + + + + $resPromises[] + + + + + + + + + + + + $info[$method] + $info[$type] + cdn_hashes[$file][$hash['offset']]]]> + TL->getConstructors()->findByPredicate($media['_'])['type'] => $media]]]> + + + $answer + $answer + $attribute + $attribute + $audio + $audio + $bytes + $bytes + $bytes + $callable + $callable + $constructor + $constructor + $constructor + $cur + $cur + $datacenter + $datacenter + $datacenter + $dir + $file + $hash + $info + + $media + $messageMedia + $messageMedia + $messageMedia + $messageMedia + $messageMedia + + + + $method + $offset + $oldOffset + $old_dc + $r + $r + $readFuture + $res + $res + $res + $res + $res + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $size + $type + $url + + + array + array{ + * ext: string, + * name: string, + * mime: string, + * size: int, + * InputFileLocation: array, + * key_fingerprint?: string, + * key?: string, + * iv?: string, + * thumb_size?: string + * } + array|null + string + + + await + + + + + $cur + $cur + $cur + $cur + + $datacenter + $dir + + + + + $offset + $offset + + + + + + + $size + $size + $size + + + cdn_hashes]]> + cdn_hashes]]> + + + write[$offset]->getFuture()->await()]]> + + + read[$offset]]]> + write[$offset]]]> + write[$offset]]]> + + + $messageMedia + $old_dc + + + decrypt + getReference + getReference + getReference + getReference + getReference + getReference + getReference + + + + + + + + + + + $res + $res + $res + $res + $res + $res + $res + $res + $res + $res + $res + $res + $res + + + + + + + + + + $speed + $speed + $time + $time + + + $size + + + + + $attr + $attr + $attr + $attr + $attr + $attr + $attr + $has_document_photo + $has_document_photo + $has_document_photo + $has_document_photo + $has_document_photo + $has_video + $has_video + $has_video + $has_video + methodCallAsyncRead( + 'messages.sendMedia', + $params + )]]> + + + $callback + + + + + + + + + + + + + + $attr + $has_document_photo + $has_video + $t + + + Message + + + + + static function (int $offset, int $size) use ($stream) { + static function (int $offset, int $size) use ($stream, $seekable, $lock) { + static function (string $payload, int $offset) use ($stream, $seekable, $lock) { + + + downloadToStream + upload + uploadEncrypted + uploadFromStream + + + $chunk + $file + $file + $file + getServeRange()]]> + getServeRange()]]> + getServeRange()]]> + getServeRange()]]> + $size + $size + $stream + $stream + + + getHeaders()]]> + downloadToStream(...)]]> + + + $chunk + $file + $messageMedia + $messageMedia + $res + $size + $stream + $stream + + + $file + $file + + + $body + $size + + + + + + + read + seek + seek + + + Lock + Lock + Settings + + + + + populateFrom + + + $cache + $dbObject + $id + $id + $id + + + + + + + + cache[$key][$id]]]> + + + $peers[$user] + db[$id]]]> + db[$id]]]> + + + $cache + $chat + $dbObject + $id + $id + $id + + $origin + + $user + + + + + + populateFrom(...))]]> + array + + + $id + + + $peers + $peers + $peers + $peers + db]]> + + + $db + + + API->chats]]> + db]]> + + + $true + + + + + $A + $client_salt + $gForHash + $g_x + + + $p + $pForHash + + $server_salt + toBytes()]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $A + $client_salt + $g + $g + $gForHash + $g_x + + + $p + $p + $pForHash + $pForHash + $server_salt + current_algo]]> + new_algo]]> + srp_id]]> + $v + + + powMod + powMod + powMod + toBytes + toString + + + $pForHash + + + $BForHash + $BForHash + + + powMod + + + + + getInfo($peer, \danog\MadelineProto\API::INFO_TYPE_CONSTRUCTOR)['forum']]]> + + + + + + $channel + $channel + $channel + $channel + $channel + $filter + $filter + $filter + $filter + $filter + $folder_id + $gres + $limit + $limit + $limit + $offset + $offset + $offset + $q + $q + $q + $q + $q + $res + $res + $total_count + $total_count + + + fetchParticipants + fetchParticipantsCache + fwdPeerIsset + getInputConstructor + getInputPeer + getParticipantsHash + recurseAlphabetSearchParticipants + + + + + + $chat + $chat + $chat + + + + + + $existingChat + $existingChat + $filter + $filter + $filter + + + + + + $id + $id + $id + + + + + + + $limit + $limit + $limit + $offset + $offset + $offset + $q + $q + $q + + + + + + + + + + + full_chats[$partial['bot_api_id']]]]> + full_chats[$partial['bot_api_id']]]]> + + + + + $username + + + await($promises) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TL->getConstructors()->findByPredicate($constructor['_'])['type']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + methodCallAsyncRead('help.getSupport', [])['user']]]> + $username + channelParticipants[$this->participantsKey($channel['channel_id'], $filter, $q, $offset, $limit)])['hash']]]> + full_chats[$id])['last_update']]]> + methodCallAsyncRead('contacts.resolveUsername', ['username' => $username]))['peer']]]> + + + + + + + getIdInternal($participant['peer'])]]]> + + + + getIdInternal($participant['peer'])]]]> + chats[$user['id']]]]> + chats[-$chat['id']]]]> + full_chats[$id]]]> + secret_chats[$id]]]> + TL->getConstructors()->findByPredicate($constructor['_'])['type'] => $constructor]]]> + + + $bot_api_id + $chat + + $entity + $existingChat + $gres + $gres + $hash + $id + $id + $id + $id + $id + $id + $id + $id + $id + $ids[] + $invite + $invite + $invite + $key + $last_count + $newchat[$field] + + + + + + + + + + $participant + $participant + $participant + $res[$key] + $res[$key] + $res[$key] + $res[$key] + $res[$key] + $res[$key] + + + + + + + + + + + + + + $size + supportUser]]> + $total_count + + + $username]]]> + + + + ($type is \danog\MadelineProto\API::INFO_TYPE_ALL ? array{ + * InputPeer: array{_: string, user_id?: int, access_hash?: int, min?: bool, chat_id?: int, channel_id?: int}, + * Peer: array{_: string, user_id?: int, chat_id?: int, channel_id?: int}, + * DialogPeer: array{_: string, peer: array{_: string, user_id?: int, chat_id?: int, channel_id?: int}}, + * NotifyPeer: array{_: string, peer: array{_: string, user_id?: int, chat_id?: int, channel_id?: int}}, + * InputDialogPeer: array{_: string, peer: array{_: string, user_id?: int, access_hash?: int, min?: bool, chat_id?: int, channel_id?: int}}, + * InputNotifyPeer: array{_: string, peer: array{_: string, user_id?: int, access_hash?: int, min?: bool, chat_id?: int, channel_id?: int}}, + * bot_api_id: int|string, + * user_id?: int, + * chat_id?: int, + * channel_id?: int, + * InputUser?: array{_: string, user_id?: int, access_hash?: int, min?: bool}, + * InputChannel?: array{_: string, channel_id: int, access_hash: int, min: bool}, + * type: string + * } : ($type is API::INFO_TYPE_TYPE ? string : ($type is \danog\MadelineProto\API::INFO_TYPE_ID ? int : array{_: string, user_id?: int, access_hash?: int, min?: bool, chat_id?: int, channel_id?: int}|array{_: string, user_id?: int, access_hash?: int, min?: bool}|array{_: string, channel_id: int, access_hash: int, min: bool}))) + ?int + ?int + array + bool + int + + + getOtherID + + + + + + + $q + + + $total_count + + + + + \danog\MadelineProto\API::PEER_TYPE_* + + + $promises + + + getIdInternal($full)]]> + getIdInternal($full)]]> + getIdInternal($id)]]> + getIdInternal($id)]]> + + + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + + + + full_chats]]> + full_chats]]> + + + + + + + + $size + + + $cached + $full + + + + + $cache + $cache + $cache + $cache + + $location + $location + + + + + + + $origin + $origin + $origin + $origin + $origin + $origin + $origin + $originType + $originType + $originType + $originType + + + + $photo + $reference + $reference + $reference + $reference + + + + + + + + $cache[$location] + $cache[$location] + $cache[$location] + $cache[$location] + + + + + + + + + + + + + + + + + + + + + API->authorization['user']['id']]]> + API->authorization['user']['id']]]> + db[$locationString]['reference']]]> + db[$location]['origins']]]> + db[$location]['reference']]]> + db[$location]['reference']]]> + + + + + + + + + + cache[$key][$location]]]> + cache[$key][$location]]]> + cache[$key][$location]]]> + cache[$key][self::serializeLocation($locationType, $location)]]]> + + + API->full_chats[$origin['peer']]]]> + API->full_chats[$origin['peer']]]]> + cache[$key][$location]]]> + cache[$key][$location]]]> + + + + $attribute + $cache + $cache + $dc_id + $frame + $frames[] + $frames[] + $fullChat + $location + $location + $location + $location + $locationValue + $locationValue + $origin + $originType + $originType + $originType + + + + + + + + + + + + + + + + + $photo + $previous + $previous + $reference + $reference + $reference + $reference + $reference + $reference + $size + + $tlTrace + + + $frame + + $tlTrace + + + API->authorization['user']]]> + API->authorization['user']]]> + API->authorization['user']['id']]]> + API->authorization['user']['id']]]> + + + $db + + + $k + + + + + + + + $length + $seek_end + $size + $subValue + $value + + + $seek_end + $seek_end + $seek_end + $size + $size + $size + + + + + $extra_ranges + $range_orig + $seek_end + + + $extra_ranges + + + + + wrapMedia([ + '_' => 'messageMediaPhoto', + 'photo' => $message['action']['photo'] + ])]]> + + + nextSent]]> + + + getUpdatesState + loadUpdateState + + + $authorization + + $button + + + + + + $result + getUpdatesState()]]> + $update + + + + + + + + + + $updates + + + + + + + + + + + + + + + + + + + + + + + + + TL->getConstructors()->findByPredicate('message')['params']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + chats[$info['bot_api_id']]['username']]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + authorization['hint']]]> + + + + + + + + + + feeders[FeedLoop::GENERIC]->feedSingle($update)]]]> + calls[$update['phone_call']['id']]]]> + calls[$update['phone_call']['id']]]]> + calls[$update['phone_call']['id']]]]> + calls[$update['phone_call']['id']]]]> + calls[$update['phone_call']['id']]]]> + calls[$update['phone_call']['id']]]]> + eventHandlerMethods[$updateType]]]> + feeders[$this->feeders[FeedLoop::GENERIC]->feedSingle($update)]]]> + feeders[$this->feeders[FeedLoop::GENERIC]->feedSingle($updates['update'])]]]> + secretFeeders[$update['message']['chat_id']]]]> + secretFeeders[$update['message']['chat_id']]]]> + secret_chats[$update['chat']['id']]]]> + secret_chats[$update['chat']['id']]]]> + secret_chats[$update['message']['chat_id']]]]> + temp_rekeyed_secret_chats[$update['chat']['id']]]]> + temp_rekeyed_secret_chats[$update['chat']['id']]]]> + temp_requested_secret_chats[$update['chat']['id']]]]> + temp_requested_secret_chats[$update['chat']['id']]]]> + + + + $authorization + $authorization + $bkey + $button + $closure + $cur_state + $data + $from_id + $from_id + $key + $key + $message_id + + $param + $result + $row + authorization]]> + authorization]]> + $to_id + $to_id + $update + $update + $updateType + + + + + + $updates + $value + + + $closure($update) + + + Message + array + ]]> + int + + + discard + qts + qts + qts + qts + qts + qts + qts + qts + + + qts()]]> + qts()]]> + qts()]]> + qts()]]> + + + + + + + + + + + + + + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + authorization['user']['id']]]> + + + msg_ids]]> + + + addPendingWakeups + waitForInternalStart + + + + + + + $first + + + break; + + + Response + + + + + int + + + + + + + pts + $update['pts_count'])]]> + + + + + + + + + + + + $res + RPCErrorException::$descriptions + RPCErrorException::$errorMethodMap + self::$emojis + + + + + + + + + + + Tools::wait($callable()) + + + completeLogin + createApp + getApp + hasApp + loop + + + $callable() + + + getHeaders('app')]]> + getHeaders('origin')]]> + getHeaders('origin')]]> + getHeaders('refer')]]> + getHeaders('refer')]]> + getHeaders('refer')]]> + + + + + + $resulta + hash]]> + + + settings]]> + + + $value + + + settings]]> + + + + + $aargs + $args + + + methodCallAsyncRead + + + $wrapper + + + + + $file + $message + + + $file + $message + + + + + $level + $message + + + self::LEVEL_MAP[$level] + + + + + $previous + + + $caller + $code + $message + + + $code + $message + + + + + $caller + $method + + + $method + + + + self::$errorMethodMap[$code][$method] + self::$errorMethodMap[$code][$method][$error] + + + self::$errorMethodMap[$code][$method] + self::$errorMethodMap[$code][$method] + + + $description + $res + + + string + + + $method + + + $description + + + + + + + $code + + + $additional + + + + + e]]> + n]]> + + + toBytes + toBytes + + + serializeObject(['type' => 'bytes'], $instance->n->toBytes(), 'key')]]> + + + $e + $fp + $n + + + + + $chat + + + completeSecretChat + requestSecretChat + + + + + + + + + + + + + + + $g_a + $g_a + $g_b + $g_b + + + + + + + secret_chats[$chat]['rekeying'][1]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]]]> + temp_requested_secret_chats[$params['id']]]]> + + + + + + secret_chats[$chat]['key']]]> + secret_chats[$chat]['key']]]> + secret_chats[$chat]['key']]]> + secret_chats[$chat]['key']]]> + secret_chats[$chat]['key']['visualization_orig']]]> + secret_chats[$chat]['key']['visualization_orig']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying'][0]]]> + secret_chats[$chat]['rekeying'][0]]]> + secret_chats[$chat]['rekeying'][0]]]> + secret_chats[$chat]['rekeying'][0]]]> + secret_chats[$chat]['rekeying'][1]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]['fingerprint']]]> + + + secret_chats[$chat]['key']]]> + secret_chats[$chat]['key']]]> + secret_chats[$chat]['old_key']]]> + secret_chats[$chat]['old_key']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['rekeying']]]> + secret_chats[$chat]['ttr']]]> + secret_chats[$chat]['ttr']]]> + secret_chats[$chat]['updated']]]> + secret_chats[$chat]['updated']]]> + + + secretFeeders[$params['id']]]]> + secretFeeders[$params['id']]]]> + secretFeeders[$params['id']]]]> + secretFeeders[$params['id']]]]> + secretFeeders[$params['id']]]]> + secretFeeders[$params['id']]]]> + secret_chats[$params['id']]]]> + secret_chats[$params['id']]]]> + secret_chats[\is_array($chat) ? $chat['chat_id'] : $chat]]]> + secret_chats[\is_array($chat) ? $chat['chat_id'] : $chat]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]]]> + temp_rekeyed_secret_chats[$params['exchange_id']]]]> + temp_requested_secret_chats[$params['id']]]]> + temp_requested_secret_chats[$params['id']]]]> + temp_requested_secret_chats[$res['id']]]]> + + + secret_chats[\is_array($chat) ? $chat['chat_id'] : $chat]]]> + secret_chats[\is_array($chat) ? $chat['chat_id'] : $chat]]]> + + + $g_a + $g_a + $g_b + $g_b + + + $res + + + array + + + powMod + powMod + powMod + powMod + + + + + + + + + + + + + + + $chat_id + $chat_id + $encrypted_data + $encrypted_data + $message_key + $message_key + $old + $old + + + $aes_iv + $aes_iv + $aes_iv + $aes_key + $aes_key + $aes_key + $encrypted_data + $encrypted_data + $message + + + + + $message_data_length + $message_data_length + $message_key + $message_key + secret_chats[$chat_id][$old ? 'old_key' : 'key']['auth_key']]]> + secret_chats[$chat_id][$old ? 'old_key' : 'key']['auth_key']]]> + secret_chats[$chat_id][$old ? 'old_key' : 'key']['auth_key']]]> + secret_chats[$chat_id]['admin']]]> + secret_chats[$chat_id]['key']['auth_key']]]> + secret_chats[$chat_id]['key']['auth_key']]]> + secret_chats[$chat_id]['key']['auth_key']]]> + secret_chats[$chat_id]['layer']]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + secret_chats[$chat_id][$old ? 'old_key' : 'key']]]> + secret_chats[$chat_id][$old ? 'old_key' : 'key']]]> + secret_chats[$chat_id][$old ? 'old_key' : 'key']]]> + secret_chats[$chat_id][$old ? 'old_key' : 'key']['auth_key']]]> + secret_chats[$chat_id][$old ? 'old_key' : 'key']['auth_key']]]> + secret_chats[$chat_id][$old ? 'old_key' : 'key']['auth_key']]]> + secret_chats[$chat_id]['admin']]]> + secret_chats[$chat_id]['admin']]]> + secret_chats[$chat_id]['admin']]]> + secret_chats[$chat_id]['admin']]]> + secret_chats[$chat_id]['key']]]> + secret_chats[$chat_id]['key']]]> + secret_chats[$chat_id]['key']]]> + secret_chats[$chat_id]['key']]]> + secret_chats[$chat_id]['key']['auth_key']]]> + secret_chats[$chat_id]['key']['auth_key']]]> + secret_chats[$chat_id]['key']['auth_key']]]> + secret_chats[$chat_id]['key']['fingerprint']]]> + secret_chats[$chat_id]['layer']]]> + secret_chats[$chat_id]['layer']]]> + secret_chats[$chat_id]['layer']]]> + secret_chats[$chat_id]['layer']]]> + secret_chats[$chat_id]['mtproto']]]> + secret_chats[$chat_id]['out_seq_no']]]> + secret_chats[$chat_id]['out_seq_no']]]> + secret_chats[$chat_id]['rekeying']]]> + secret_chats[$chat_id]['rekeying'][0]]]> + secret_chats[$chat_id]['ttr']]]> + secret_chats[$chat_id]['updated']]]> + secret_chats[$message['message']['chat_id']]['in_seq_no']]]> + secret_chats[$message['message']['chat_id']]['key']]]> + secret_chats[$message['message']['chat_id']]['mtproto']]]> + secret_chats[$message['message']['chat_id']]['old_key']]]> + secret_chats[$message['message']['chat_id']]['rekeying']]]> + secret_chats[$message['message']['chat_id']]['ttr']]]> + secret_chats[$message['message']['chat_id']]['ttr']]]> + secret_chats[$message['message']['chat_id']]['updated']]]> + + + + + secret_chats[$chat_id]['out_seq_no']]]> + secret_chats[$chat_id]['outgoing']]]> + secret_chats[$chat_id]['outgoing'][$this->secret_chats[$chat_id]['out_seq_no']]]]> + secret_chats[$chat_id]['ttr']]]> + secret_chats[$message['message']['chat_id']]['incoming']]]> + secret_chats[$message['message']['chat_id']]['incoming'][$this->secret_chats[$message['message']['chat_id']]['in_seq_no']]]]> + secret_chats[$message['message']['chat_id']]['mtproto']]]> + secret_chats[$message['message']['chat_id']]['mtproto']]]> + secret_chats[$message['message']['chat_id']]['ttr']]]> + + + secret_chats[$chat_id]]]> + secret_chats[$chat_id]]]> + secret_chats[$chat_id]['outgoing'][$this->secret_chats[$chat_id]['out_seq_no']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]]]> + secret_chats[$message['message']['chat_id']]['incoming'][$this->secret_chats[$message['message']['chat_id']]['in_seq_no']]]]> + + + $deserialized + $message + + $message_data_length + $message_data_length + + + + + + + + + + + secret_chats[$chat_id]['key']['fingerprint']]]> + secret_chats[$chat_id]['out_seq_no']]]> + secret_chats[$chat_id]['ttr']]]> + secret_chats[$chat_id]['updated']]]> + secret_chats[$message['message']['chat_id']]['ttr']]]> + secret_chats[$message['message']['chat_id']]['updated']]]> + + + + + $action + $action + $action + $chatId + $chatId + $chatId + + + + + + + + + + + + + + + + + + secret_chats[$chatId]['created']]]> + secret_chats[$chatId]['created']]]> + secret_chats[$chatId]['in_seq_no']]]> + secret_chats[$chatId]['layer']]]> + secret_chats[$chatId]['out_seq_no_x']]]> + secret_chats[$chatId]['out_seq_no_x']]]> + secret_chats[$chatId]['outgoing']]]> + + + + + + + + + secret_chats[$chatId]['in_seq_no']]]> + secret_chats[$chatId]['layer']]]> + secret_chats[$chatId]['layer']]]> + secret_chats[$chatId]['mtproto']]]> + secret_chats[$chatId]['ttl']]]> + + + + secret_chats[$chatId]]]> + secret_chats[$chatId]]]> + secret_chats[$chatId]]]> + secret_chats[$chatId]]]> + secret_chats[$chatId]]]> + secret_chats[$chatId]]]> + secret_chats[$chatId]]]> + + + $action + + + + + $chatId + $decryptedMessage + $message + $seq + + + + + + + + $chatId + secret_chats[$chatId]['created']]]> + secret_chats[$chatId]['created']]]> + secret_chats[$chatId]['in_seq_no']]]> + + + + + $chat + $chat + $chat_id + $chat_id + $seqno + $seqno + + + checkSecretInSeqNo + checkSecretOutSeqNo + generateSecretInSeqNo + generateSecretOutSeqNo + + + $chat_id + $chat_id + $chat_id + $chat_id + + + + + + + + secret_chats[$chat]['in_seq_no']]]> + secret_chats[$chat]['in_seq_no_x']]]> + secret_chats[$chat]['layer']]]> + secret_chats[$chat]['layer']]]> + secret_chats[$chat]['out_seq_no']]]> + secret_chats[$chat]['out_seq_no_x']]]> + secret_chats[$chat_id]['in_seq_no']]]> + secret_chats[$chat_id]['in_seq_no_x']]]> + secret_chats[$chat_id]['in_seq_no_x']]]> + secret_chats[$chat_id]['incoming']]]> + secret_chats[$chat_id]['incoming']]]> + secret_chats[$chat_id]['out_seq_no']]]> + secret_chats[$chat_id]['out_seq_no_x']]]> + secret_chats[$chat_id]['out_seq_no_x']]]> + secret_chats[$chat_id]['out_seq_no_x']]]> + + + secret_chats[$chat]]]> + secret_chats[$chat]]]> + secret_chats[$chat]]]> + secret_chats[$chat]]]> + secret_chats[$chat]]]> + secret_chats[$chat]]]> + secret_chats[$chat_id]]]> + secret_chats[$chat_id]]]> + + + $last + $message + $message + $seqno + $seqno + $temp + + + + + + $seqno + $seqno + $seqno + $seqno + secret_chats[$chat]['in_seq_no']]]> + secret_chats[$chat]['out_seq_no']]]> + secret_chats[$chat_id]['out_seq_no']]]> + + + + + [$unserialized, $unlock] + + + $class + $class + + + getFuture()]]> + getFuture()]]> + getFuture()]]> + + + $class + $class + $copy + $res + $unserialized + + + array{0: (ChannelledSocket|APIWrapper|Throwable|null|0), 1: (callable|null)} + + + cancel + getEventHandler + getEventHandler + + + $ipcSocket + $ipcSocket + $ipcSocket + $ipcSocket + getIpcPath(), $cancelIpc->getFuture())]]> + getIpcPath(), $cancelIpc->getFuture())]]> + getIpcPath(), $cancelIpc->getFuture(), customE: new AssertionError("Please make sure the $class class is in scope, or that the event handler is running (in a separate process or in the current process)."))]]> + getIpcPath(), $cancelIpc->getFuture(), customE: new AssertionError("Please make sure the $class class is in scope, or that the event handler is running (in a separate process or in the current process)."))]]> + + + $ipcSocket + $ipcSocket + + + $unserialized + + + $warningId + + + + + unserialize($this->ipcStatePath)]]> + + + $unserialized + + + ?object + + + $unserialized + + + ?IpcState + + + read(null, 1)]]> + read(null, 1)]]> + $php[0] + $php[1] + + + $php[0] + $php[1] + + + lightState ??= $this->unserialize($this->lightStatePath)]]> + + + + + + + + $array + + + Lang::$current_lang + Lang::$current_lang + Lang::$current_lang + + + + + + + + + + + + + + $array + + + + + + $protocol + $proxy + + + $transport + + + + + + + + $settings[$array] + $settings[$array] + + + + $array + $array + $key + $protocol + $proxy + $settings + $settings + $transport + + + $proxies + + + + + $settings[$array] + + + $array + + + + + $settings + + + $settings + + + + + + + + + $settings + + + $settings + + + + + + + + + $settings + + + $settings + + + + + + + + + + + + $settings[$array] + + + $array + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + extra]]> + + + extra]]> + + + + + + + + $array + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + parent::__sleep() + + + + + + $settings + $src + + + + + $prop + + + $prop + + + + + + isTerminated + + + + + $message + + + $message + + + + + + + + + + + + + + + + $stream + + + bufferRead(4)]]> + + + $buffer + $buffer + $length + $length + + + RawStreamInterface + Socket + \danog\MadelineProto\Stream\ReadBufferInterface + \danog\MadelineProto\Stream\WriteBufferInterface + + + bufferRead + bufferRead + bufferWrite + bufferWrite + checkReadHash + checkWriteHash + disconnect + getReadBuffer + getSocket + getWriteBuffer + startReadHash + startWriteHash + + + $length + bufferRead(4))[1]]]> + + + $buffer + $buffer + stream]]> + stream->getSocket()]]> + + + $l + + + + + $append + $append_after + $memory_stream + $stream + + + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + + + ?string + RawStreamInterface + Socket + + + disconnect + getSocket + read + write + + + append]]> + append_after]]> + + + stream]]> + stream->getSocket()]]> + stream->read($cancellation)]]> + + + + + $append + $append_after + $decrypt + $encrypt + $extra + $read_buffer + $stream + $write_buffer + + + extra['decrypt']['iv']]]> + extra['decrypt']['key']]]> + extra['encrypt']['iv']]]> + extra['encrypt']['key']]]> + + + extra['decrypt']]]> + extra['decrypt']]]> + extra['decrypt']['iv']]]> + extra['decrypt']['key']]]> + extra['encrypt']]]> + extra['encrypt']]]> + extra['encrypt']['iv']]]> + extra['encrypt']['key']]]> + + + AES + AES + RawStreamInterface + Socket + string + + + bufferRead + bufferWrite + disconnect + encrypt + getReadBuffer + getSocket + getWriteBuffer + + + append]]> + append_after]]> + + + decrypt]]> + encrypt]]> + stream]]> + stream->getSocket()]]> + decrypt->encrypt($this->read_buffer->bufferRead($length))]]> + + + $data + + + + + $append + $append_after + + + read + write + + + + + $hash_name + $read_buffer + $read_check_after + $read_check_pos + $read_hash + $rev + $stream + $write_buffer + $write_check_after + $write_check_pos + $write_hash + + + $data + $data + hash_name]]> + hash_name]]> + read_hash]]> + read_hash]]> + read_hash]]> + write_hash]]> + write_hash]]> + write_hash]]> + + + $data + $data + + + ?string + RawStreamInterface + Socket + + + bufferRead + bufferRead + bufferRead + bufferRead + bufferWrite + bufferWrite + bufferWrite + disconnect + getReadBuffer + getSocket + getWriteBuffer + + + read_check_pos]]> + read_check_pos]]> + read_check_pos]]> + write_check_pos]]> + write_check_pos]]> + write_check_pos]]> + + + $data + $data + read_buffer->bufferRead($length)]]> + stream]]> + stream->getSocket()]]> + + + + + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + memory_stream]]> + + + RawStreamInterface + + + stream]]> + - - $ctx->getStream($header) + + getStream($header)]]> - - UdpBufferedStream - + + close + + + $append + $append_after + + + + + $obj + + + $socketContext + $uri + + + $extra + + + + + + $extra + $extra + + + array + + + connect + new $clazz() + + + $extra + + + StreamInterface + + + + + $stream + + + bufferRead(1)]]> + + + $buffer + $buffer + $length + $length + + + RawStreamInterface + Socket + \danog\MadelineProto\Stream\ReadBufferInterface + \danog\MadelineProto\Stream\WriteBufferInterface + + + bufferRead + bufferRead + bufferWrite + disconnect + getReadBuffer + getSocket + getWriteBuffer + + + bufferRead(3)]]> + $length + + + $buffer + $buffer + stream]]> + stream->getSocket()]]> + + + $l + + + + + $in_seq_no + $out_seq_no + $stream + + + bufferRead(4)]]> + bufferRead(4)]]> + + + $buffer + $buffer + $in_seq_no + $length + $read_length + + + RawStreamInterface + Socket + \danog\MadelineProto\Stream\ReadBufferInterface + \danog\MadelineProto\Stream\WriteBufferInterface + + + bufferRead + bufferRead + bufferWrite + checkReadHash + checkWriteHash + disconnect + getReadBuffer + getSocket + getWriteBuffer + startReadHash + startWriteHash + + + $read_length + $read_length + in_seq_no]]> + out_seq_no]]> + + + $buffer + $buffer + stream]]> + stream->getSocket()]]> + + + $l + + + + + $stream + $stream + $uri + + + $code + $ctx + $header + + + ctx]]> + ctx]]> + + + string + + + + + header]]> + + + code]]> + + + bufferRead(1)]]> + $piece + uri->getPort()]]> + + + $code + $current_header[1] + $description + + + getStream($header)]]> + + + $description + + + + + $stream + + + bufferRead(4)]]> + + + $buffer + $buffer + $length + + + RawStreamInterface + Socket + \danog\MadelineProto\Stream\ReadBufferInterface + \danog\MadelineProto\Stream\WriteBufferInterface + + + bufferRead + bufferWrite + disconnect + getReadBuffer + getSocket + getWriteBuffer + + + $buffer + $buffer + stream]]> + stream->getSocket()]]> + + + $l + + + + + $stream + + + bufferRead(4)]]> + + + $buffer + $buffer + $length + + + RawStreamInterface + Socket + \danog\MadelineProto\Stream\ReadBufferInterface + \danog\MadelineProto\Stream\WriteBufferInterface + + + bufferRead + bufferWrite + disconnect + getReadBuffer + getSocket + getWriteBuffer + + + $buffer + $buffer + stream]]> + stream->getSocket()]]> + + + $l + + + + + $extra + $stream + + + + + + + + + extra['address']]]> + extra['port']]]> + extra['secret']]]> + extra['secret']]]> + + + extra['address']]]> + extra['port']]]> + extra['secret']]]> + extra['secret']]]> + + + + + ]]> + + + $content[$offset++] + $content[$offset++] + $content[$offset++] + $content[$offset++] + + + emitter]]> + ]]> + ]]> + + + $offset + $offset + $offset + $offset + $offset + $offset + $size + + + currentDuration += $frameDuration]]> + currentDuration += $totalDuration]]> + + + $emitter + $packFormat + $stream + $streamCount + + + getReadBuffer($l)]]> + + + $offset + $offset + $offset + $offset + + + $stereo + + + + + $stream + + + $extra + + + $l + + + extra['address']]]> + extra['port']]]> + + + extra['address']]]> + extra['password']]]> + extra['port']]]> + extra['username']]]> + + + $read + + + bufferRead(1)]]> + $piece + $port + + + $code + $current_header[1] + $description + + + $l + + + getStream()]]> + + + $read + + + + + $stream + + + $extra + + + extra['password']]]> + extra['username']]]> + + + extra['address']]]> + extra['password']]]> + extra['port']]]> + extra['username']]]> + + + $port + + + $port + extra['address']]]> + extra['password']]]> + extra['port']]]> + extra['username']]]> + + + bufferRead(1)]]> + bufferRead(1)]]> + bufferRead(1)]]> + bufferRead(1)]]> + bufferRead(1)]]> + bufferRead(1)]]> + bufferRead(1)]]> + bufferRead(1)]]> + bufferRead(1)]]> + bufferRead(16)]]> + bufferRead(2)]]> + bufferRead(4)]]> + $length + + + $ip + + + $ip + + + getStream(\chr(5).\chr(\strlen($methods)).$methods)]]> + + + + + setupTls + + + + + getStream + + + write + + + write + + + + + $connector + $stream + + + ?string + + + $data + + + $data + + + + + $markup + + + parseReplyMarkup + + + + + + + $arguments[$key] + $arguments[$key] + + + + + + + + + + + + + + + + + + + + $element + + + + $max_length + + TYPES_IDS[$type_name] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + TYPES_IDS[$type_name] + + + + + + + + + + + + + + + + + + + + + + + $arguments[$mtproto] + + $attribute + $audio + $button + $button + $button + $data + + $element + $entity + $entity + $entity + + + + $key + + + $max_length + + + + + + + + + + + + $newentity + + + + + + + + + + + + + $offset + $offset + $photo + + + + + + + + + + + + + + + + + + + $row + + + + + + + + + + + $offset + $offset + $offset + + + + + + + + + }>]]> + + + + + + + + + + + + + + $arguments[$key] + + + + + + $photo + $photoSize + $thumbnail + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $thumbnail + + + + + $file + $message + + + $file + $message + + + + + $posClose === false + $posClose === false + + + $start + + + + + MTProtoToTd + MTProtoToTdcli + tdToTdcli + + + $params[$td] + + $value + + + $key + $key + + + $params[$mtproto[0]][$mtproto[1]] + + + + + + + authorization['user']['id']]]> + + + + + + + + + + $newparams[$key] + $newparams[$mtproto[0]] + $newparams[$mtproto[0]] + $newparams[$td] + $newparams[$td] + $newparams[$td] + $newparams[$td] + $newparams[$td] + $newparams[$td] + + + + + + $value + $value + + + array + + + + + + + + + + + + + authorization['user']]]> + authorization['user']['id']]]> + + + + + + + + + + + + + + + $file + $message + + + $file + $message + + + + + + + + + + + + + + + + $frame + + + + + + + + + + + \is_resource($stream) + \is_resource($stream) + + + API->getInfo($arguments[$current_argument['name']]))['InputEncryptedChat']]]> + + + $result + + + >]]> + + + $arg + $v + $v + + + deserialize + serializeMethod + serializeObject + serializeParams + + + + + $arg + $arguments + + + + + + + + + + + + $button + $constructorData + $constructorData + $current_argument + $current_argument + $current_argument + + + + $elem + $elem + $file + $file + $long_len + $object + $object + $object + $object + $object + $object + toBytes()]]> + + + + $pair + $predicate + $tl + + + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]->getConstructor()]]> + + + + + + + + + + + + -$long_len + + + + + + + \is_int($object) ? (float) $object : $object + + + $cb + $id + $id + $k + $k + $scheme_type + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + constructors->findByPredicate($arguments[$current_argument['name']]['_'])['type']]]> + constructors->findByPredicate($arguments[$current_argument['name']]['_'])['type']]]> + constructors->findByPredicate($object['_'])['type']]]> + constructors->findByPredicate('vector')['id']]]> + constructors->findByPredicate('vector')['id']]]> + constructors->findByPredicate((bool) $object ? 'boolTrue' : 'boolFalse')['id']]]> + + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + afterConstructorDeserialization[$x['_']]]]> + afterConstructorDeserialization[$x['_']]]]> + afterMethodResponseDeserialization[$type['connection']->outgoing_messages[$x['req_msg_id']]->getConstructor()]]]> + afterMethodResponseDeserialization[$type['connection']->outgoing_messages[$x['req_msg_id']]->getConstructor()]]]> + beforeConstructorDeserialization[$x['_']]]]> + beforeConstructorDeserialization[$x['_']]]]> + beforeConstructorSerialization[$object['_']]]]> + beforeConstructorSerialization[$object['_']]]]> + tdDescriptions['constructors'][$name]]]> + tdDescriptions['constructors'][$name]]]> + tdDescriptions['constructors'][$name]]]> + tdDescriptions['constructors'][$name]]]> + tdDescriptions['methods'][$name]]]> + tdDescriptions['methods'][$name]]]> + typeMismatch[$type['type']]]]> + typeMismatch[$type['type']]]]> + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]]]> + outgoing_messages[$x['req_msg_id']]]]> + + + + + + + + + + + afterConstructorDeserialization[$x['_']]]]> + afterConstructorDeserialization[$x['_']]]]> + + + $arg + + + + + + + + $bkey + $button + $concat + $concat + $constructorData + $constructorData + $constructorData + $constructorData + $constructorData + $constructorData + $constructorData + + + $count + $cur_flag + $current_argument + $current_object + $current_object + $data + $data + $elem + $elem + $file + $id + $id + $key + $key + $key + $long_len + $name + $name + $object + $object + $object + + $pair + $pair + $predicate + + $result[] + $row + secretLayer]]> + secretLayer]]> + $tl + + $v + $value + $value + $value + $value + $value + + + + getConstructor + getConstructor + getConstructor + toBytes + + + $concat + $concat + + + + + + + + + + + + + constructors->findByPredicate('vector')['id']]]> + serializeObject($current_argument, $arguments[$current_argument['name']], $current_argument['name'], $layer)]]> + serializeObject($current_argument, $arguments['file']['mime_type'], $current_argument['name'], $layer)]]> + serializeObject($current_argument, $this->API->encryptSecretMessage($arguments['peer']['chat_id'], $arguments['message'], $arguments['queuePromise']), 'data')]]> + serializeObject(['type' => $type['subtype']], $current_object, $k, $layer)]]> + serializeObject(['type' => $type['subtype']], $current_object, $k, $layer)]]> + serializeObject(['type' => 'bytes'], Tools::random(15 + 4 * Tools::randomInt(modulus: 3)), 'random_bytes')]]> + + $value + $value + $values[$bytePos+1] + $values[$bytePos] + + + + + + + + + + + + outgoing_messages]]> + outgoing_messages]]> + + + mutexSideEffects]]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + API->logger]]> + + + botAPIToMTProto + logger + + + $elem[1] + $elem[1] + $elem[1] + $elem[1] + + + $afterConstructorDeserialization + $afterMethodResponseDeserialization + $beforeConstructorDeserialization + $beforeConstructorSerialization + $beforeMethodResponseDeserialization + $constructors + $methods + $tdDescriptions + $typeMismatch + + + (string) $object + (string) $object + (string) $object + + + $value + $value + + + \stream_get_contents + \stream_get_contents + + + $a + + + + + findByPredicate + findByType + + + + + + + + by_id[$json_dict['id']]['layer']]]> + + + + + + + by_id[$json_dict['id']]['layer']]]> + + + by_id[$chosenid]]]> + by_id[$json_dict['id']]]]> + by_id[$json_dict['id']]]]> + by_id[$json_dict['id']]]]> + by_id[$json_dict['id']]]]> + by_id[$json_dict['id']]]]> + by_id[$this->by_predicate_and_layer[$predicate]]]]> + layers[$json_dict['layer']]]]> + + + $alayer + $chosenid + $chosenid + $constructor + $constructor + $constructor + $constructor + + + + + array|false + + + $alayer + $alayer + $alayer + $alayer + + + + + + $constructor + + + + + deserialize + serializeMethod + serializeObject + + + + + findById + findByMethod + + + + + + + + + + + + by_id[$json_dict['id']]]]> + by_id[$this->by_method[$method_name]]]]> + by_method[$json_dict['method']]]]> + + + $method + $method + + + + + + + + + + + + + + + + + + + by_id[$key]['params']]]> + + + + + + + + + + + + + + + + + by_id[$key]['params']]]> + by_id[$key]['params'][$kkey]]]> + + + by_id[$key]['params'][$kkey]]]> + + + $kkey + $param + + + + + + + + click + + + authorization['user']['id']]]> + + + + + button[$name]]]> + button[$name]]]> + button[$name]]]> + button[$name]]]> + + + id]]> + label]]> + peer]]> + peer]]> + + + authorization['user']]]> + authorization['user']['id']]]> + + + + + $c->name !== null]]> + + + $val + + + $this->{$var}]]> + + + end + getVar + + + $cb + $hash + + + + + + + + + + + + + + + + + + + + + + + + + + + $curPixels + $hash + $hash + $hash + $hash + $long + $max + $max + $maxPixels + $parent + $size + $size + + + + float + int + int + + + getAttribute + + + $hash + $hash + $hash + $hash + $hash + $hash + > 21]]> + + + + + + + + + $value + $value + + + $value + + + $this->{$var}, + $obj, + $obj::class, + )->__invoke()]]> + {$var} =& $val; + }, + $obj, + $obj::class, + )->__invoke()]]> + + + __invoke + __invoke + + + {$var} =& $val]]> + + + $f + + + + + $stream + + + $TLID_DECRYPTED_AUDIO_BLOCK + $TLID_REFLECTOR_PEER_INFO + $TLID_REFLECTOR_SELF_INFO + $TLID_SIMPLE_AUDIO_BLOCK + $callID + $configuration + $creatorID + $holdFiles + $inputFiles + $internalStorage + $isPlaying + $otherID + $outputFile + $protocol + $received_timestamp_map + $remote_ack_timestamp_map + $session_in_seq_no + $session_out_seq_no + $signal + $storage + $visualization + $voip_state + + + openFile + + + + + + + + $file + callID]]> + callID]]> + configuration['auth_key']]]> + inputFiles]]> + tempHoldFiles]]> + + + + + + + + + + + callID['id']]]> + configuration['auth_key']]]> + configuration['endpoints']]]> + internalStorage['created']]]> + + + inputFiles[]]]> + inputFiles[]]]> + + + $endpoint + $file + $file + $id + $it + $payload + tempHoldFiles]]> + + + array + array + int + int + int|bool + string|int + + + advance + advance + getCurrent + getCurrent + + + + + + + + callID]]> + internalStorage['created'] ?? false]]> + internalStorage['created'] ?? false]]> + otherID]]> + protocol]]> + signal]]> + visualization]]> + + + $authKey + + + $cnt + $cnt + $cnt + + + + + $ack_mask + $last_ack_id + $packet_seq_no + $s1 + $s2 + + + received_packet + seqgt + + + received_timestamp_map[$diff]]]> + received_timestamp_map[$x]]]> + remote_ack_timestamp_map[$x]]]> + remote_ack_timestamp_map[$x]]]> + + + received_timestamp_map[$diff+$x]]]> + received_timestamp_map[$diff]]]> + received_timestamp_map[$x]]]> + received_timestamp_map[0]]]> + remote_ack_timestamp_map[$diff+$x]]]> + remote_ack_timestamp_map[$x]]]> + remote_ack_timestamp_map[$x]]]> + remote_ack_timestamp_map[0]]]> + + + received_timestamp_map[$diff+$x]]]> + received_timestamp_map[$diff]]]> + received_timestamp_map[$diff]]]> + remote_ack_timestamp_map[$diff+$x]]]> + + + $diff + $diff + $diff + $remaining + $remaining + + + $ack_mask + $diff + $diff + $diff + $diff + $last_ack_id + $packet_seq_no + session_in_seq_no]]> + + + + + $controller + $id + + + completeCall + confirmCall + requestCall + + + + + + + + + + + + + + + + subtract(Magic::$two)]]> + subtract(Magic::$two)]]> + $g_a + $g_b + + + + + + + + + + + calls[$call['id']]->getOtherID()]]> + calls[$params['id']]->configuration]]> + calls[$params['id']]->configuration]]> + calls[$params['id']]->configuration['endpoints']]]> + calls[$params['id']]->configuration['endpoints']]]> + calls[$params['id']]->getOtherID()]]> + calls[$params['id']]->getOtherID()]]> + calls[$params['id']]->storage['a']]]> + calls[$params['id']]->storage['b']]]> + calls[$params['id']]->storage['g_a']]]> + + + + + + + + + + + + + + + + + + + calls[$params['id']]->configuration['endpoints']]]> + calls[$params['id']]->configuration['endpoints']]]> + calls[$params['id']]->storage['a']]]> + calls[$params['id']]->storage['b']]]> + calls[$params['id']]->storage['g_a']]]> + calls[$params['id']]->storage['g_a']]]> + calls[$params['id']]->storage['g_a_hash']]]> + methodCallAsyncRead('phone.confirmCall', ['key_fingerprint' => \substr(\sha1($key, true), -8), 'peer' => ['id' => $params['id'], 'access_hash' => $params['access_hash'], '_' => 'inputPhoneCall'], 'g_a' => $this->calls[$params['id']]->storage['g_a'], 'protocol' => ['_' => 'phoneCallProtocol', 'udp_reflector' => true, 'min_layer' => 65, 'max_layer' => VoIP::getConnectionMaxLayer()]]))['phone_call']]]> + + + calls[$params['id']]->configuration['endpoints']]]> + calls[$params['id']]->configuration['endpoints']]]> + calls[$res['phone_call']['id']]->storage['b']]]> + + + calls[$call['id']]]]> + calls[$call['id']]]]> + calls[$call['id']]]]> + calls[$call['id']]]]> + calls[$call['id']]]]> + calls[$call['id']]]]> + calls[$call['id']]]]> + calls[$call['id']]]]> + calls[$id]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$res['phone_call']['id']]]]> + calls[$res['phone_call']['id']]]]> + + + $c + $g_a + $g_b + $res + $res + $res + $res + $visualization[] + $visualization[] + + + ?VoIP + array + int + + + discard + getCallState + getCallState + getDebugLog + getOtherID + getOtherID + getOtherID + getPreferredRelayID + parseConfig + parseConfig + powMod + powMod + setCall + setVisualization + setVisualization + startTheMagic + startTheMagic + subtract + subtract + whenCreated + + + calls[$call['id']]->whenCreated()]]> + config['call_connect_timeout_ms']]]> + config['call_connect_timeout_ms']]]> + config['call_receive_timeout_ms']]]> + config['call_receive_timeout_ms']]]> + + + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$params['id']]]]> + calls[$res['phone_call']['id']]]]> + + + calls[$params['id']]->configuration]]> + calls[$params['id']]->configuration]]> + calls[$params['id']]->configuration]]> + calls[$params['id']]->configuration]]> + calls[$params['id']]->configuration]]> + calls[$params['id']]->configuration]]> + calls[$params['id']]->storage]]> + calls[$params['id']]->storage]]> + calls[$params['id']]->storage]]> + calls[$params['id']]->storage]]> + calls[$params['id']]->storage]]> + calls[$params['id']]->storage]]> + calls[$res['phone_call']['id']]->storage]]> + + + + + + + + + + $res + + + + + read + + + $aes_iv + $aes_iv + $aes_key + $aes_key + + + $innerLen + + + read + + + $payload + + + + + $args + $datacenter + $object + $stream + + + pack_string + recv_message + send_message + unpack_string + + + + + + + + + + + + + + + + + + + + + + + + $codec + $flags + $flags + $flags + $flags + $length + $length + $length + $long_len + $object + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $payload + $stream + $stream + $stream + $stream + $stream + $stream + + + + session_in_seq_no]]> + session_in_seq_no]]> + session_in_seq_no]]> + session_out_seq_no]]> + session_out_seq_no]]> + session_out_seq_no]]> + unpack_string($payload)]]> + unpack_string($payload)]]> + -$long_len + + + $args[$x] + $args[$x] + $args[$x] + $args[$x] + $args[$x] + $args[$x] + $args[$x] + $args[$x] + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + configuration['call_id']]]> + configuration['call_id']]]> + received_timestamp_map[$x]]]> + + + + + + + + + + + + + $ack_mask + $ack_mask + $ack_mask + $codec + $codec + $flags + $flags + $flags + $flags + $flags + $flags + $flags + $in_seq_no + $in_seq_no + $in_seq_no + $length + $length + $length + $long_len + $out_seq_no + $out_seq_no + $out_seq_no + $payload + $payload + $payload + + + + + + + + + + $stream + + + write + + + + + + + + + + + $codec + $flags + $flags + $flags + $flags + $flags + $flags + $flags + $flags + $payload + $payload + + configuration['call_id']]]> + pack_string($args['extra'])]]> + pack_string($message)]]> + pack_string($message)]]> + + + + $ack_mask + $in_seq_no + $out_seq_no + + + \stream_get_contents + \stream_get_contents + \stream_get_contents + \stream_get_contents + + + $flags + + + + + $result + + + $cache[0] + $cache[1] + + + $cache + $result + $result + + + ?array + bool + + + + + array|true + + + + + ]]> + + + $chat + + + + + + + + + + + + + + + + + authorization['user']['bot']]]> + authorization['user']['bot']]]> + authorization['user']['bot']]]> + authorization['user']['bot']]]> + botDialogsUpdatesState['pts']]]> + methodCallAsyncRead( + 'updates.getDifference', + $state, + ['cancellation' => Tools::getTimeoutCancellation(15.0), 'FloodWaitLimit' => 86400] + )['_']]]> + + + + + + $chat + $dialog + $dialogs[$id] + $id + $last_date + $last_id + $message + $res + $res[] + $result + $result + botDialogsUpdatesState]]> + botDialogsUpdatesState]]> + bottomPts]]> + topPts]]> + + + ]]> + + + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']]]> + authorization['user']['bot']]]> + authorization['user']['bot']]]> + authorization['user']['bot']]]> + authorization['user']['bot']]]> + + + $dialogs + + + chats]]> + chats]]> + + + + + event_handler_instance === null || $this->event_handler_instance instanceof __PHP_Incomplete_Class]]> + event_handler_instance instanceof __PHP_Incomplete_Class]]> + + + $pluginsNew + + + PluginEventHandler|EventHandlerProxy|null + + + pluginInstances[$class]]]> + pluginInstances[$class]]]> + pluginInstances[$class]]]> + pluginInstances[$class]]]> + pluginInstances[$class]]]> + + + new $class_name + + + + + array + + + completePhoneLogin + phoneLogin + + + $authorization + $authorization + + + $res + methodCallAsyncRead( + 'auth.importBotAuthorization', + [ + 'bot_auth_token' => $token, + 'api_id' => $this->settings->getAppInfo()->getApiId(), + 'api_hash' => $this->settings->getAppInfo()->getApiHash(), + ], + )]]> + methodCallAsyncRead('account.getPassword', [])]]> + methodCallAsyncRead('auth.signUp', ['phone_number' => $this->authorization['phone_number'], 'phone_code_hash' => $this->authorization['phone_code_hash'], 'phone_code' => $this->authorization['phone_code'], 'first_name' => $first_name, 'last_name' => $last_name])]]> + + + + + + + + + + + + + authorization['hint']]]> + authorization['hint']]]> + authorization['phone_number']]]> + + + $authorization + $authorization + $authorization + $res + $res + authorization]]> + authorization]]> + authorization]]> + authorization]]> + authorization]]> + authorization]]> + + + authorization['phone_code']]]> + authorization['phone_code_hash']]]> + authorization['phone_code_hash']]]> + authorization['phone_number']]]> + authorization['phone_number']]]> + + + \is_array($auth_key) + + + + + loop + + + $r + $r + $r + + + logger + logger + + + + + + + + getAuthorization() === \danog\MadelineProto\API::LOGGED_IN]]> + + + start + + + $title + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $firstName + $lastName + $title + $title + $title + + + + + + + + + + + + + + + + + + + + + + + + + + + + + $result + $result + + + ?LoginQrCode + ?LoginQrCode + ?LoginQrCode + + + $form + + + + + function ($_) use ($callback) { + + + $result + $result + $result + $result + + + $callback() + $callback() + diff --git a/psalm.xml b/psalm.xml index 584171de9..f5a250eee 100644 --- a/psalm.xml +++ b/psalm.xml @@ -1,6 +1,6 @@