@mtkruto/node 0.1.170 → 0.1.183

package/script/client/1_client_encrypted.d.ts

@@ -0,0 +1,34 @@
+import { enums, functions, ReadObject, TLObject, types } from "../2_tl.js";
+import { ClientAbstract } from "./0_client_abstract.js";
+import { ClientAbstractParams } from "./0_client_abstract.js";
+export type ErrorSource = "deserialization" | "decryption" | "unknown";
+export interface Handlers {
+    serverSaltReassigned?: (newServerSalt: bigint) => void;
+    updates?: (updates: enums.Updates | enums.Update, call: TLObject | null, callback?: () => void) => void;
+    result?: (result: ReadObject, callback: () => void) => void;
+    error?: (err: unknown, source: ErrorSource) => void;
+}
+/**
+ * An MTProto client for making encrypted connections. Most users won't need to interact with this. Used internally by `Client`.
+ *
+ * There are a few things to note:
+ *
+ * - This is a bare client and it stores nothing.
+ * - It expects an authorization key to be present before invoking any method.
+ * - Authorization must be set using `setAuthKey`.
+ * - Incoming packets that aren't a reply to a specific call are passed to the assigned handlers.
+ * - It doesn't uncompress compressed packets.
+ */
+export declare class ClientEncrypted extends ClientAbstract {
+    #private;
+    handlers: Handlers;
+    constructor(params?: ClientAbstractParams);
+    connect(): Promise<void>;
+    setAuthKey(key: Uint8Array): Promise<void>;
+    get authKey(): Uint8Array;
+    set serverSalt(serverSalt: bigint);
+    get serverSalt(): bigint;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait: true): Promise<void>;
+    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait?: boolean): Promise<T | void>;
+}

package/script/client/1_client_encrypted.js

@@ -0,0 +1,241 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ClientEncrypted_instances, _ClientEncrypted_authKey, _ClientEncrypted_authKeyId, _ClientEncrypted_sessionId, _ClientEncrypted_state, _ClientEncrypted_toAcknowledge, _ClientEncrypted_recentAcks, _ClientEncrypted_promises, _ClientEncrypted_L, _ClientEncrypted_LreceiveLoop, _ClientEncrypted_Linvoke, _ClientEncrypted_nextMessageId, _ClientEncrypted_nextSeqNo, _ClientEncrypted_sendMessage, _ClientEncrypted_receiveLoop;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientEncrypted = void 0;
+const _0_deps_js_1 = require("../0_deps.js");
+const _1_utilities_js_1 = require("../1_utilities.js");
+const _2_tl_js_1 = require("../2_tl.js");
+const _4_errors_js_1 = require("../4_errors.js");
+const _0_client_abstract_js_1 = require("./0_client_abstract.js");
+const _0_message_js_1 = require("./0_message.js");
+const _0_types_js_1 = require("./0_types.js");
+// global ClientEncrypted ID counter for logs
+let id = 0;
+/**
+ * An MTProto client for making encrypted connections. Most users won't need to interact with this. Used internally by `Client`.
+ *
+ * There are a few things to note:
+ *
+ * - This is a bare client and it stores nothing.
+ * - It expects an authorization key to be present before invoking any method.
+ * - Authorization must be set using `setAuthKey`.
+ * - Incoming packets that aren't a reply to a specific call are passed to the assigned handlers.
+ * - It doesn't uncompress compressed packets.
+ */
+class ClientEncrypted extends _0_client_abstract_js_1.ClientAbstract {
+    constructor(params) {
+        super(params);
+        _ClientEncrypted_instances.add(this);
+        _ClientEncrypted_authKey.set(this, new Uint8Array());
+        _ClientEncrypted_authKeyId.set(this, 0n);
+        _ClientEncrypted_sessionId.set(this, (0, _1_utilities_js_1.getRandomBigInt)(8, true, false));
+        _ClientEncrypted_state.set(this, { serverSalt: 0n, seqNo: 0, messageId: 0n });
+        _ClientEncrypted_toAcknowledge.set(this, new Set());
+        _ClientEncrypted_recentAcks.set(this, new _1_utilities_js_1.CacheMap(20));
+        _ClientEncrypted_promises.set(this, new Map());
+        // loggers
+        _ClientEncrypted_L.set(this, void 0);
+        _ClientEncrypted_LreceiveLoop.set(this, void 0);
+        _ClientEncrypted_Linvoke.set(this, void 0);
+        // receive loop handlers
+        Object.defineProperty(this, "handlers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        const L = __classPrivateFieldSet(this, _ClientEncrypted_L, (0, _1_utilities_js_1.getLogger)("ClientEncrypted").client(id++), "f");
+        __classPrivateFieldSet(this, _ClientEncrypted_LreceiveLoop, L.branch("receiveLoop"), "f");
+        __classPrivateFieldSet(this, _ClientEncrypted_Linvoke, L.branch("invoke"), "f");
+    }
+    async connect() {
+        await super.connect();
+        (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_receiveLoop).call(this)); // TODO: ability to join this promise
+    }
+    async setAuthKey(key) {
+        const hash = await (0, _1_utilities_js_1.sha1)(key);
+        __classPrivateFieldSet(this, _ClientEncrypted_authKeyId, (0, _1_utilities_js_1.bigIntFromBuffer)(hash.slice(-8), true, false), "f");
+        __classPrivateFieldSet(this, _ClientEncrypted_authKey, key, "f");
+    }
+    get authKey() {
+        return __classPrivateFieldGet(this, _ClientEncrypted_authKey, "f");
+    }
+    set serverSalt(serverSalt) {
+        __classPrivateFieldGet(this, _ClientEncrypted_state, "f").serverSalt = serverSalt;
+    }
+    get serverSalt() {
+        return __classPrivateFieldGet(this, _ClientEncrypted_state, "f").serverSalt;
+    }
+    async invoke(function_, noWait) {
+        const messageId = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this);
+        const message__ = new _2_tl_js_1.Message_(messageId, __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, true), function_);
+        let message_;
+        let container = undefined;
+        if (__classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f").size) {
+            const ack = new _2_tl_js_1.Message_(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this), __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, false), new _2_tl_js_1.types.Msgs_ack({ msg_ids: [...__classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f")] }));
+            __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").set(ack.id, { container, message: ack });
+            message_ = new _2_tl_js_1.MessageContainer(container = __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextMessageId).call(this), __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_nextSeqNo).call(this, false), [message__, ack]);
+        }
+        else {
+            message_ = message__;
+        }
+        await __classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, message_);
+        __classPrivateFieldGet(this, _ClientEncrypted_Linvoke, "f").debug("invoked", function_[_2_tl_js_1.name]);
+        if (noWait) {
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").set(messageId, {
+                container,
+                message: message__,
+                call: function_,
+            });
+            return;
+        }
+        return await new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").set(messageId, { container, message: message__, resolve, reject, call: function_ });
+        }).then((v) => v);
+    }
+}
+exports.ClientEncrypted = ClientEncrypted;
+_ClientEncrypted_authKey = new WeakMap(), _ClientEncrypted_authKeyId = new WeakMap(), _ClientEncrypted_sessionId = new WeakMap(), _ClientEncrypted_state = new WeakMap(), _ClientEncrypted_toAcknowledge = new WeakMap(), _ClientEncrypted_recentAcks = new WeakMap(), _ClientEncrypted_promises = new WeakMap(), _ClientEncrypted_L = new WeakMap(), _ClientEncrypted_LreceiveLoop = new WeakMap(), _ClientEncrypted_Linvoke = new WeakMap(), _ClientEncrypted_instances = new WeakSet(), _ClientEncrypted_nextMessageId = function _ClientEncrypted_nextMessageId() {
+    return __classPrivateFieldGet(this, _ClientEncrypted_state, "f").messageId = (0, _0_message_js_1.getMessageId)(__classPrivateFieldGet(this, _ClientEncrypted_state, "f").messageId);
+}, _ClientEncrypted_nextSeqNo = function _ClientEncrypted_nextSeqNo(contentRelated) {
+    let seqNo = __classPrivateFieldGet(this, _ClientEncrypted_state, "f").seqNo * 2;
+    if (contentRelated) {
+        seqNo++;
+        __classPrivateFieldGet(this, _ClientEncrypted_state, "f").seqNo++;
+    }
+    return seqNo;
+}, _ClientEncrypted_sendMessage = async function _ClientEncrypted_sendMessage(message) {
+    const payload = await (0, _0_message_js_1.encryptMessage)(message, __classPrivateFieldGet(this, _ClientEncrypted_authKey, "f"), __classPrivateFieldGet(this, _ClientEncrypted_authKeyId, "f"), __classPrivateFieldGet(this, _ClientEncrypted_state, "f").serverSalt, __classPrivateFieldGet(this, _ClientEncrypted_sessionId, "f"));
+    await this.transport.transport.send(payload);
+}, _ClientEncrypted_receiveLoop = async function _ClientEncrypted_receiveLoop() {
+    if (!this.transport) {
+        (0, _1_utilities_js_1.UNREACHABLE)();
+    }
+    while (this.connected) {
+        try {
+            const buffer = await this.transport.transport.receive();
+            __classPrivateFieldGet(this, _ClientEncrypted_L, "f").inBin(buffer);
+            let decrypted;
+            try {
+                decrypted = await ((0, _0_message_js_1.decryptMessage)(buffer, __classPrivateFieldGet(this, _ClientEncrypted_authKey, "f"), __classPrivateFieldGet(this, _ClientEncrypted_authKeyId, "f"), __classPrivateFieldGet(this, _ClientEncrypted_sessionId, "f")));
+                __classPrivateFieldGet(this, _ClientEncrypted_L, "f").in(decrypted);
+            }
+            catch (err) {
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").error("failed to decrypt message:", err);
+                this.handlers.error?.(err, "decryption");
+                continue;
+            }
+            const messages = decrypted instanceof _2_tl_js_1.MessageContainer ? decrypted.messages : [decrypted];
+            for (const message of messages) {
+                let body = message.body;
+                if (body instanceof _2_tl_js_1.types.Gzip_packed) {
+                    body = new _2_tl_js_1.TLReader((0, _0_deps_js_1.gunzip)(body.packed_data)).readObject();
+                }
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("received", (typeof body === "object" && _2_tl_js_1.name in body) ? body[_2_tl_js_1.name] : body.constructor.name);
+                if (body instanceof _2_tl_js_1.types._Updates || body instanceof _2_tl_js_1.types._Update) {
+                    this.handlers.updates?.(body, null);
+                }
+                else if (body instanceof _2_tl_js_1.types.New_session_created) {
+                    this.serverSalt = body.server_salt;
+                    this.handlers.serverSaltReassigned?.(this.serverSalt);
+                }
+                else if (message.body instanceof _2_tl_js_1.RPCResult) {
+                    let result = message.body.result;
+                    if (result instanceof _2_tl_js_1.types.Gzip_packed) {
+                        result = new _2_tl_js_1.TLReader((0, _0_deps_js_1.gunzip)(result.packed_data)).readObject();
+                    }
+                    if (result instanceof _2_tl_js_1.types.Rpc_error) {
+                        __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("RPCResult:", result.error_code, result.error_message);
+                    }
+                    else {
+                        __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("RPCResult:", (typeof result === "object" && _2_tl_js_1.name in result) ? result[_2_tl_js_1.name] : result.constructor.name);
+                    }
+                    const messageId = message.body.messageId;
+                    const promise = __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").get(messageId);
+                    const resolvePromise = () => {
+                        if (promise) {
+                            if (result instanceof _2_tl_js_1.types.Rpc_error) {
+                                promise.reject?.((0, _4_errors_js_1.upgradeInstance)(result, promise.call));
+                            }
+                            else {
+                                promise.resolve?.(result);
+                            }
+                            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(messageId);
+                        }
+                    };
+                    if (result instanceof _2_tl_js_1.types._Updates || result instanceof _2_tl_js_1.types._Update) {
+                        this.handlers.updates?.(result, promise?.call ?? null, resolvePromise);
+                    }
+                    else {
+                        this.handlers.result?.(result, resolvePromise);
+                    }
+                }
+                else if (message.body instanceof _2_tl_js_1.types.Pong) {
+                    const promise = __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").get(message.body.msg_id);
+                    if (promise) {
+                        promise.resolve?.(message.body);
+                        __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(message.body.msg_id);
+                    }
+                }
+                else if (message.body instanceof _2_tl_js_1.types.Bad_server_salt) {
+                    __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").debug("server salt reassigned");
+                    this.serverSalt = message.body.new_server_salt;
+                    this.handlers.serverSaltReassigned?.(this.serverSalt);
+                    const promise = __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").get(message.body.bad_msg_id);
+                    const ack = __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").get(message.body.bad_msg_id);
+                    if (promise) {
+                        (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, promise.message));
+                    }
+                    else if (ack) {
+                        (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, ack.message));
+                    }
+                    else {
+                        for (const promise of __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").values()) {
+                            if (promise.container && promise.container == message.body.bad_msg_id) {
+                                (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, promise.message));
+                            }
+                        }
+                        for (const ack of __classPrivateFieldGet(this, _ClientEncrypted_recentAcks, "f").values()) {
+                            if (ack.container && ack.container == message.body.bad_msg_id) {
+                                (0, _1_utilities_js_1.drop)(__classPrivateFieldGet(this, _ClientEncrypted_instances, "m", _ClientEncrypted_sendMessage).call(this, ack.message));
+                            }
+                        }
+                    }
+                }
+                __classPrivateFieldGet(this, _ClientEncrypted_toAcknowledge, "f").add(message.id);
+            }
+        }
+        catch (err) {
+            if (!this.connected) {
+                break;
+            }
+            else if (err instanceof _2_tl_js_1.TLError) {
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").error("failed to deserialize:", err);
+                this.handlers.error?.(err, "deserialization");
+            }
+            else {
+                __classPrivateFieldGet(this, _ClientEncrypted_LreceiveLoop, "f").error("unexpected error:", err);
+            }
+        }
+    }
+    if (!this.connected) {
+        for (const [key, { reject }] of __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").entries()) {
+            reject?.(new _0_types_js_1.ConnectionError("Connection was closed"));
+            __classPrivateFieldGet(this, _ClientEncrypted_promises, "f").delete(key);
+        }
+    }
+    else {
+        (0, _1_utilities_js_1.UNREACHABLE)();
+    }
+};

package/script/client/{2_client_plain.d.ts → 1_client_plain.d.ts}

@@ -7,6 +7,9 @@ export interface ClientPlainParams extends ClientAbstractParams {
      */
     publicKeys?: PublicKeys;
 }
+/**
+ * An MTProto client for making plain connections. Most users won't need to interact with this. Used internally for creating authorization keys.
+ */
 export declare class ClientPlain extends ClientAbstract {
     #private;
     constructor(params?: ClientPlainParams);

package/script/client/{2_client_plain.js → 1_client_plain.js}

@@ -21,11 +21,14 @@ const _0_client_abstract_js_1 = require("./0_client_abstract.js");
 const _0_message_js_1 = require("./0_message.js");
 const L = (0, _1_utilities_js_1.getLogger)("ClientPlain");
 const LcreateAuthKey = L.branch("createAuthKey");
+/**
+ * An MTProto client for making plain connections. Most users won't need to interact with this. Used internally for creating authorization keys.
+ */
 class ClientPlain extends _0_client_abstract_js_1.ClientAbstract {
     constructor(params) {
         super(params);
         _ClientPlain_publicKeys.set(this, void 0);
-        _ClientPlain_lastMsgId.set(this, 0n);
+        _ClientPlain_lastMsgId.set(this, 0n); // TODO: refactor
         __classPrivateFieldSet(this, _ClientPlain_publicKeys, params?.publicKeys ?? _4_constants_js_1.PUBLIC_KEYS, "f");
     }
     async invoke(function_) {

package/script/client/1_composer.d.ts

@@ -1,7 +1,7 @@
+import { MaybePromise } from "../1_utilities.js";
 import { Update, UpdateIntersection, User } from "../3_types.js";
 import { FilterQuery, WithFilter } from "./0_filters.js";
-type MaybePromise<T> = T | Promise<T>;
-export type NextFunction = () => Promise<void>;
+export type NextFunction<T = void> = () => Promise<T>;
 export type MiddlewareFn<C> = (ctx: C, next: NextFunction) => MaybePromise<unknown>;
 export interface MiddlewareObj<C> {
     middleware: () => MiddlewareFn<C>;
@@ -27,4 +27,3 @@ export declare class Composer<C extends {
         prefixes: string | string[];
     }, ...middleware: Middleware<WithFilter<C, "message:text">>[]): Composer<WithFilter<C, "message:text">>;
 }
-export {};

package/script/client/2_message_manager.d.ts

@@ -33,7 +33,7 @@ export declare class MessageManager {
     sendVideo(chatId: ID, video: FileSource, params?: SendVideoParams): Promise<import("../3_types.js").MessageVideo>;
     sendDocument(chatId: ID, document: FileSource, params?: SendDocumentParams): Promise<import("../3_types.js").MessageDocument>;
     sendPhoto(chatId: ID, photo: FileSource, params?: SendPhotoParams): Promise<import("../3_types.js").MessagePhoto>;
-    resolveFileId(maybeFileId: string, expectedFileType: FileType): {
+    resolveFileId(maybeFileId: string, expectedFileType: FileType | FileType[]): {
         id: bigint;
         access_hash: bigint;
         file_reference: Uint8Array;

package/script/client/2_message_manager.js

@@ -392,7 +392,7 @@ class MessageManager {
         let media = null;
         const spoiler = params?.hasSpoiler ? true : undefined;
         if (typeof photo === "string") {
-            const fileId = this.resolveFileId(photo, _3_types_js_2.FileType.Photo);
+            const fileId = this.resolveFileId(photo, [_3_types_js_2.FileType.Photo, _3_types_js_2.FileType.ProfilePhoto]);
             if (fileId != null) {
                 media = new _2_tl_js_1.types.InputMediaPhoto({
                     id: new _2_tl_js_1.types.InputPhoto(fileId),
@@ -414,6 +414,7 @@ class MessageManager {
         return (0, _3_types_js_2.assertMessageType)(message, "photo");
     }
     resolveFileId(maybeFileId, expectedFileType) {
+        expectedFileType = Array.isArray(expectedFileType) ? expectedFileType : [expectedFileType];
         let fileId = null;
         try {
             fileId = (0, _3_types_js_1.deserializeFileId)(maybeFileId);
@@ -422,7 +423,7 @@ class MessageManager {
             __classPrivateFieldGet(this, _MessageManager_LresolveFileId, "f").warning(err);
         }
         if (fileId != null) {
-            if (fileId.type != expectedFileType) {
+            if (!expectedFileType.includes(fileId.type)) {
                 (0, _1_utilities_js_1.UNREACHABLE)();
             }
             return {

package/script/client/4_client.d.ts

@@ -2,25 +2,12 @@ import { MaybePromise } from "../1_utilities.js";
 import { enums, functions, types } from "../2_tl.js";
 import { Storage } from "../3_storage.js";
 import { DC } from "../3_transport.js";
-import { BotCommand, Chat, ChatAction, ChatMember, ChatP, FileSource, ID, InactiveChat, InlineQueryResult, InputStoryContent, InviteLink, Message, MessageAnimation, MessageAudio, MessageContact, MessageDice, MessageDocument, MessageLocation, MessagePhoto, MessagePoll, MessageText, MessageVenue, MessageVideo, MessageVideoNote, MessageVoice, NetworkStatistics, ParseMode, Reaction, Sticker, Story, Update, UpdateIntersection, User } from "../3_types.js";
+import { BotCommand, Chat, ChatAction, ChatMember, ChatP, FileSource, ID, InactiveChat, InlineQueryResult, InputStoryContent, InviteLink, Message, MessageAnimation, MessageAudio, MessageContact, MessageDice, MessageDocument, MessageLocation, MessagePhoto, MessagePoll, MessageText, MessageVenue, MessageVideo, MessageVideoNote, MessageVoice, NetworkStatistics, ParseMode, Reaction, Sticker, Story, Update, User } from "../3_types.js";
 import { Migrate } from "../4_errors.js";
-import { ClientAbstract } from "./0_client_abstract.js";
-import { FilterQuery, WithFilter } from "./0_filters.js";
 import { AddReactionParams, AnswerCallbackQueryParams, AnswerInlineQueryParams, AuthorizeUserParams, BanChatMemberParams, CreateInviteLinkParams, CreateStoryParams, DeleteMessageParams, DeleteMessagesParams, DownloadParams, EditMessageParams, EditMessageReplyMarkupParams, ForwardMessagesParams, GetChatsParams, GetCreatedInviteLinksParams, GetHistoryParams, GetMyCommandsParams, PinMessageParams, ReplyParams, SearchMessagesParams, SendAnimationParams, SendAudioParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams, SetChatMemberRightsParams, SetChatPhotoParams, SetMyCommandsParams, SetReactionsParams, UploadParams } from "./0_params.js";
 import { Api } from "./0_types.js";
-import { Composer, Middleware } from "./1_composer.js";
-import { ClientPlainParams } from "./2_client_plain.js";
-export type NextFn<T = void> = () => Promise<T>;
-export interface InvokeErrorHandler<C> {
-    (ctx: {
-        client: C;
-        error: unknown;
-        function: types.Type | functions.Function<unknown>;
-        n: number;
-    }, next: NextFn<boolean>): MaybePromise<boolean>;
-}
-declare const getEntity: unique symbol;
-export declare const handleMigrationError: unique symbol;
+import { ClientPlainParams } from "./1_client_plain.js";
+import { Composer as Composer_, NextFunction } from "./1_composer.js";
 export interface Context {
     /** The client that received the update. */
     client: Client;
@@ -148,10 +135,27 @@ export interface Context {
     block: () => Promise<void>;
     /** Context-aware alias for `client.unblockUser()`. */
     unblock: () => Promise<void>;
+    /** Context-aware alias for `client.getChatMember()`. */
+    getChatMember: (userId: ID) => Promise<ChatMember>;
+    /** Context-aware alias for `client.setChatStickerSet()`. */
+    setChatStickerSet: (setName: string) => Promise<void>;
+    /** Context-aware alias for `client.deleteChatStickerSet()`. */
+    deleteChatStickerSet: () => Promise<void>;
     toJSON: () => Update;
 }
-export declare function skipInvoke<C extends Context>(): InvokeErrorHandler<Client<C>>;
+export declare class Composer<C extends Context = Context> extends Composer_<C> {
+}
+export interface InvokeErrorHandler<C> {
+    (ctx: {
+        client: C;
+        error: unknown;
+        function: types.Type | functions.Function<unknown>;
+        n: number;
+    }, next: NextFunction<boolean>): MaybePromise<boolean>;
+}
 export declare const restartAuth: unique symbol;
+export declare const handleMigrationError: unique symbol;
+declare const getEntity: unique symbol;
 export interface ClientParams extends ClientPlainParams {
     /** A parse mode to use when the `parseMode` parameter is not specified when sending or editing messages. Defauls to `ParseMode.None`. */
     parseMode?: ParseMode;
@@ -167,8 +171,6 @@ export interface ClientParams extends ClientPlainParams {
     systemLangCode?: string;
     /** The system_version parameter to be passed to initConnection when calling `authorize`. The default varies by the current runtime. */
     systemVersion?: string;
-    /** Whether to automatically call `start` with no parameters in the first `invoke` call. Defaults to `true`. */
-    autoStart?: boolean;
     /** Whether to use default handlers. Defaults to `true`. */
     defaultHandlers?: boolean;
     /** Whether to ignore outgoing messages. Defaults to `true` for bots, and `false` for users. */
@@ -182,7 +184,10 @@ export interface ClientParams extends ClientPlainParams {
     /** Whether to store messages. Defaults to `false`. */
     storeMessages?: boolean;
 }
-export declare class Client<C extends Context = Context> extends ClientAbstract {
+/**
+ * An MTKruto client.
+ */
+export declare class Client<C extends Context = Context> extends Composer<C> {
     #private;
     readonly apiId: number | null;
     readonly apiHash: string | null;
@@ -197,13 +202,14 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
     /**
      * Constructs the client.
      *
-     * @param storage The storage provider to use. Defaults to memory storage. Passing a string constructs a memory storage with the string being the string session.
+     * @param storage The storage provider to use. Defaults to memory storage. Passing a string constructs a memory storage with the string being the auth string.
      * @param apiId App's API ID from [my.telegram.org](https://my.telegram.org/apps). Defaults to 0 (unset).
      * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Defaults to empty string (unset).
      */
     constructor(storage?: Storage | string | null, apiId?: number | null, apiHash?: string | null, params?: ClientParams);
+    get connected(): boolean;
+    get disconnected(): boolean;
     api: Api;
-    protected stateChangeHandler: (connected: boolean) => void;
     /**
      * Sets the DC and resets the auth key stored in the session provider
      * if the stored DC was not the same as the `dc` parameter.
@@ -217,6 +223,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      * Before establishing the connection, the session is saved.
      */
     connect(): Promise<void>;
+    reconnect(dc: DC): Promise<void>;
     [handleMigrationError](err: Migrate): Promise<void>;
     disconnect(): Promise<void>;
     /**
@@ -259,22 +266,28 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
     send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
     exportAuthString(): Promise<string>;
     importAuthString(authString: string): Promise<void>;
+    /**
+     * Get a chat's inputPeer. Useful when calling API functions directly.
+     *
+     * @param id The identifier of the chat.
+     */
     getInputPeer(id: ID): Promise<enums.InputPeer>;
+    /**
+     * Get a channel or a supergroup's inputChannel. Useful when calling API functions directly.
+     *
+     * @param id The identifier of the channel or the supergroup.
+     */
     getInputChannel(id: ID): Promise<types.InputChannel>;
+    /**
+     * Get a user's inputUser. Useful when calling API functions directly.
+     *
+     * @param id The identifier of the user.
+     */
     getInputUser(id: ID): Promise<types.InputUser>;
     private [getEntity];
     private [getEntity];
     private [getEntity];
     private [getEntity];
-    use(...middleware: Middleware<UpdateIntersection<C>>[]): Composer<C>;
-    branch(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, trueHandler_: Middleware<UpdateIntersection<C>>, falseHandler_: Middleware<UpdateIntersection<C>>): Composer<C>;
-    filter<D extends C>(predicate: (ctx: UpdateIntersection<C>) => ctx is D, ...middleware: Middleware<D>[]): Composer<D>;
-    filter(predicate: (ctx: UpdateIntersection<C>) => MaybePromise<boolean>, ...middleware: Middleware<UpdateIntersection<C>>[]): Composer<C>;
-    on<Q extends FilterQuery>(filter: Q, ...middleware: Middleware<WithFilter<C, Q>>[]): Composer<UpdateIntersection<WithFilter<C, Q>>>;
-    command(commands: string | RegExp | (string | RegExp)[] | {
-        names: string | RegExp | (string | RegExp)[];
-        prefixes: string | string[];
-    }, ...middleware: Middleware<WithFilter<C, "message:text">>[]): Composer<WithFilter<C, "message:text">>;
     /**
      * Send a text message.
      *
@@ -295,7 +308,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      */
     editMessageText(chatId: ID, messageId: number, text: string, params?: EditMessageParams): Promise<MessageText>;
     /**
-     * Edit an inline message's text.
+     * Edit an inline message's text. Bot-only.
      *
      * @method ms
      * @param inlineMessageId The inline message's identifier.
@@ -312,7 +325,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      */
     editMessageReplyMarkup(chatId: ID, messageId: number, params?: EditMessageReplyMarkupParams): Promise<Message>;
     /**
-     * Edit an inline message's reply markup.
+     * Edit an inline message's reply markup. Bot-only.
      *
      * @method ms
      * @param inlineMessageId The inline message's identifier.
@@ -646,7 +659,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      */
     getCustomEmojiStickers(id: string | string[]): Promise<Sticker[]>;
     /**
-     * Set a chat's available reactions.
+     * Set a chat's available reactions. User-only.
      *
      * @method ch
      * @param chatId The identifier of the chat.
@@ -696,7 +709,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      */
     deleteChatPhoto(chatId: number): Promise<void>;
     /**
-     * Delete all messages sent by a specific member of a chat.
+     * Delete all messages sent by a specific member of a chat. User-only.
      *
      * @method ms
      * @param chatId The identifier of the chat. Must be a supergroup.
@@ -893,7 +906,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      */
     getInactiveChats(): Promise<InactiveChat[]>;
     /**
-     * Search the messages of a chat.
+     * Search the messages of a chat. User-only.
      *
      * @method ms
      * @param chatId The identifier of the chat to search the messages in.
@@ -901,7 +914,7 @@ export declare class Client<C extends Context = Context> extends ClientAbstract
      */
     searchMessages(chatId: ID, query: string, params?: SearchMessagesParams): Promise<Message[]>;
     /**
-     * Set the number of boosts required to circument a chat's default restrictions.
+     * Set the number of boosts required to circument a chat's default restrictions. User-only.
      *
      * @method ch
      * @param chatId The identifier of the chat.