@mtkruto/node 0.1.170 → 0.1.190

package/esm/0_deps.d.ts

@@ -1,7 +1,7 @@
-export * from "./deps/deno.land/std@0.219.0/assert/mod.js";
-export * as path from "./deps/deno.land/std@0.219.0/path/mod.js";
-export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.219.0/encoding/base64.js";
-import { contentType as contentType_ } from "./deps/deno.land/std@0.219.0/media_types/content_type.js";
+export * from "./deps/deno.land/std@0.221.0/assert/mod.js";
+export * as path from "./deps/deno.land/std@0.221.0/path/mod.js";
+export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.221.0/encoding/base64.js";
+import { contentType as contentType_ } from "./deps/deno.land/std@0.221.0/media_types/content_type.js";
 export declare const contentType: typeof contentType_;
 export declare function extension(mimeType: string): string;
 export { ctr256, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.3.3/mod.js";

package/esm/0_deps.js

@@ -1,7 +1,7 @@
-export * from "./deps/deno.land/std@0.219.0/assert/mod.js";
-export * as path from "./deps/deno.land/std@0.219.0/path/mod.js";
-export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.219.0/encoding/base64.js";
-import { contentType as contentType_ } from "./deps/deno.land/std@0.219.0/media_types/content_type.js";
+export * from "./deps/deno.land/std@0.221.0/assert/mod.js";
+export * as path from "./deps/deno.land/std@0.221.0/path/mod.js";
+export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.221.0/encoding/base64.js";
+import { contentType as contentType_ } from "./deps/deno.land/std@0.221.0/media_types/content_type.js";
 export const contentType = (extentionOrType) => {
     if (extentionOrType == "tgs") {
         return "application/x-tgsticker";
@@ -10,7 +10,7 @@ export const contentType = (extentionOrType) => {
         return contentType_(extentionOrType);
     }
 };
-import { extension as extension_ } from "./deps/deno.land/std@0.219.0/media_types/extension.js";
+import { extension as extension_ } from "./deps/deno.land/std@0.221.0/media_types/extension.js";
 export function extension(mimeType) {
     if (mimeType == "application/x-tgsticker") {
         return "tgs";

package/esm/4_constants.d.ts

@@ -1,10 +1,9 @@
 import { DC } from "./3_transport.js";
-export declare const ACK_THRESHOLD = 10;
 export type PublicKeys = readonly [bigint, [bigint, bigint]][];
 export declare const PUBLIC_KEYS: PublicKeys;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 176;
-export declare const APP_VERSION = "MTKruto 0.1.170";
+export declare const APP_VERSION = "MTKruto 0.1.190";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/4_constants.js

@@ -1,5 +1,4 @@
 import * as dntShim from "./_dnt.shims.js";
-export const ACK_THRESHOLD = 10;
 export const PUBLIC_KEYS = Object.freeze([
     [
         1562291298945373506n,
@@ -53,9 +52,9 @@ export const PUBLIC_KEYS = Object.freeze([
 ]);
 export const INITIAL_DC = "2";
 export const LAYER = 176;
-export const APP_VERSION = "MTKruto 0.1.170";
+export const APP_VERSION = "MTKruto 0.1.190";
 // @ts-ignore: lib
-export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
+export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : (navigator.userAgent.split(" ")[0] || "Unknown") : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const LANG_CODE = typeof navigator === "undefined" || typeof navigator.language !== "string" ? "en" : navigator.language.split("-")[0];
 export const LANG_PACK = "";
 export const SYSTEM_LANG_CODE = LANG_CODE;

package/esm/5_client.d.ts

@@ -1,4 +1,4 @@
 export * from "./client/0_params.js";
-export * from "./client/2_client_plain.js";
+export * from "./client/1_client_plain.js";
+export * from "./client/1_client_encrypted.js";
 export * from "./client/4_client.js";
-export * from "./client/5_composer.js";

package/esm/5_client.js

@@ -1,4 +1,4 @@
 export * from "./client/0_params.js";
-export * from "./client/2_client_plain.js";
+export * from "./client/1_client_plain.js";
+export * from "./client/1_client_encrypted.js";
 export * from "./client/4_client.js";
-export * from "./client/5_composer.js";

package/esm/client/0_client_abstract.d.ts

@@ -16,16 +16,18 @@ export interface ClientAbstractParams {
 }
 export declare abstract class ClientAbstract {
     #private;
-    protected readonly initialDc: DC;
-    protected transportProvider: TransportProvider;
-    protected readonly cdn: boolean;
+    readonly initialDc: DC;
+    transportProvider: TransportProvider;
+    readonly cdn: boolean;
     protected transport?: ReturnType<TransportProvider>;
     constructor(params?: ClientAbstractParams);
-    protected stateChangeHandler?: (connected: boolean) => void;
+    stateChangeHandler?: (connected: boolean) => void;
+    get dc(): DC;
     get dcId(): number;
     setDc(dc: DC): MaybePromise<void>;
     get connected(): boolean;
     connect(): Promise<void>;
     reconnect(dc?: DC): Promise<void>;
     disconnect(): Promise<void>;
+    get disconnected(): boolean;
 }

package/esm/client/0_client_abstract.js

@@ -1,14 +1,14 @@
+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 __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 _ClientAbstract_dc;
 import { initTgCrypto } from "../0_deps.js";
 import { transportProviderWebSocket } from "../3_transport.js";
@@ -50,6 +50,9 @@ export class ClientAbstract {
         this.transportProvider = params?.transportProvider ?? transportProviderWebSocket();
         this.cdn = params?.cdn ?? false;
     }
+    get dc() {
+        return __classPrivateFieldGet(this, _ClientAbstract_dc, "f") ?? this.initialDc;
+    }
     get dcId() {
         if (!this.transport) {
             throw new Error("Not connected");
@@ -84,5 +87,8 @@ export class ClientAbstract {
         await this.transport.transport.deinitialize();
         await this.transport.connection.close();
     }
+    get disconnected() {
+        return !this.transport?.transport.initialized;
+    }
 }
 _ClientAbstract_dc = new WeakMap();

package/esm/client/0_html.js

@@ -75,11 +75,5 @@ export function parseHtml(html) {
     });
     parser.write(html);
     parser.end();
-    text = text.trimEnd();
-    for (const entity of entities) {
-        while (text[entity.offset + (entity.length - 1)] === undefined) {
-            --entity.length;
-        }
-    }
     return [text, entities];
 }

package/esm/client/0_markdown.d.ts

@@ -0,0 +1,21 @@
+import { MessageEntity } from "../3_types.js";
+export declare const CODEPOINTS: {
+    "\t": number;
+    "\r": number;
+    "\0": number;
+    "\v": number;
+    "\n": number;
+    " ": number;
+    _: number;
+    "[": number;
+    "]": number;
+    "(": number;
+    ")": number;
+    "`": number;
+    "~": number;
+    "\\": number;
+    "*": number;
+    "!": number;
+    "|": number;
+};
+export declare function parseMarkdown(text_: string): [string, MessageEntity[]];

package/esm/client/0_markdown.js

@@ -0,0 +1,321 @@
+/**
+ * Copyright (c) 2023 Dunkan
+ * Copyright (c) 2024 Roj
+ */
+import { UNREACHABLE } from "../1_utilities.js";
+import { sortMessageEntities } from "../3_types.js";
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+export const CODEPOINTS = {
+    "\t": 9,
+    "\r": 13,
+    "\0": 0,
+    "\v": 11,
+    "\n": 10,
+    " ": 32,
+    "_": 95,
+    "[": 91,
+    "]": 93,
+    "(": 40,
+    ")": 41,
+    "`": 96,
+    "~": 126,
+    "\\": 92,
+    "*": 42,
+    "!": 33,
+    "|": 124,
+};
+function isUtf8CharacterFirstCodeUnit(c) {
+    return (c & 0xC0) !== 0x80;
+}
+function isWhitespace(codepoint) {
+    return (codepoint === CODEPOINTS[" "] || codepoint === CODEPOINTS["\t"] || codepoint === CODEPOINTS["\r"] ||
+        codepoint === CODEPOINTS["\n"] || codepoint === CODEPOINTS["\0"] || codepoint === CODEPOINTS["\v"]);
+}
+function getUrl(url_) {
+    try {
+        const url = new URL(url_);
+        if (url.protocol != "http:" && url.protocol != "https:" && url.protocol != "tg:" && url.protocol != "ton:") {
+            return "";
+        }
+        else {
+            return url.href;
+        }
+    }
+    catch {
+        return "";
+    }
+}
+function getLinkUserId(url_) {
+    try {
+        const url = new URL(url_);
+        if (url.protocol != "tg:" || url.hostname != "user" || url.pathname.slice(1) != "" || url.port != "") {
+            return 0;
+        }
+        return Number(url.searchParams.get("id")) || 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function getLinkCustomEmojiId(url_) {
+    try {
+        const url = new URL(url_);
+        if (url.protocol != "tg:" || url.hostname != "emoji" || url.pathname.slice(1) != "" || url.port != "") {
+            return "";
+        }
+        const id_ = url.searchParams.get("id");
+        if (!id_) {
+            return "";
+        }
+        const id = BigInt(id_);
+        if (!id) {
+            return "";
+        }
+        else {
+            return String(id);
+        }
+    }
+    catch {
+        return "";
+    }
+}
+export function parseMarkdown(text_) {
+    const text = enc.encode(text_);
+    let resultSize = 0;
+    let entities = [];
+    let utf16Offset = 0;
+    const nestedEntities = [];
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === CODEPOINTS["\\"] && text[i + 1] != null && text[i + 1] > 0 && text[i + 1] <= 126) {
+            i++;
+            utf16Offset += 1;
+            text[resultSize++] = text[i];
+            continue;
+        }
+        let reservedCharacters = enc.encode("_*[]()~`>#+-=|{}.!");
+        if (nestedEntities.length !== 0) {
+            switch (nestedEntities[nestedEntities.length - 1].type) {
+                case "code":
+                case "pre":
+                    reservedCharacters = Uint8Array.of(CODEPOINTS["`"]);
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (!reservedCharacters.includes(text[i])) {
+            if (isUtf8CharacterFirstCodeUnit(c)) {
+                utf16Offset += 1 + (c >= 0xf0 ? 1 : 0);
+            }
+            text[resultSize++] = text[i];
+            continue;
+        }
+        let isEndOfAnEntity = false;
+        if (nestedEntities.length !== 0) {
+            isEndOfAnEntity = (() => {
+                switch (nestedEntities[nestedEntities.length - 1].type) {
+                    case "bold":
+                        return c === CODEPOINTS["*"];
+                    case "italic":
+                        return c === CODEPOINTS["_"] && text[i + 1] !== CODEPOINTS["_"];
+                    case "code":
+                        return c === CODEPOINTS["`"];
+                    case "pre":
+                        return c === CODEPOINTS["`"] && text[i + 1] === CODEPOINTS["`"] && text[i + 2] === CODEPOINTS["`"];
+                    case "textLink":
+                        return c === CODEPOINTS["]"];
+                    case "underline":
+                        return c === CODEPOINTS["_"] && text[i + 1] === CODEPOINTS["_"];
+                    case "strikethrough":
+                        return c === CODEPOINTS["~"];
+                    case "spoiler":
+                        return c === CODEPOINTS["|"] && text[i + 1] === CODEPOINTS["|"];
+                    case "customEmoji":
+                        return c === CODEPOINTS["]"];
+                    default:
+                        UNREACHABLE();
+                }
+            })();
+        }
+        if (!isEndOfAnEntity) {
+            let type;
+            let argument = new Uint8Array();
+            const entityByteOffset = i;
+            switch (c) {
+                case CODEPOINTS["_"]:
+                    if (text[i + 1] === CODEPOINTS["_"]) {
+                        type = "underline";
+                        i++;
+                    }
+                    else {
+                        type = "italic";
+                    }
+                    break;
+                case CODEPOINTS["*"]:
+                    type = "bold";
+                    break;
+                case CODEPOINTS["~"]:
+                    type = "strikethrough";
+                    break;
+                case CODEPOINTS["|"]:
+                    if (text[i + 1] === CODEPOINTS["|"]) {
+                        i++;
+                        type = "spoiler";
+                    }
+                    else {
+                        throw new Error(`Character '${String.fromCharCode(c)}' is reserved and must be escaped with the preceding '\\'`);
+                    }
+                    break;
+                case CODEPOINTS["["]:
+                    type = "textLink";
+                    break;
+                case CODEPOINTS["`"]:
+                    if (text[i + 1] === CODEPOINTS["`"] && text[i + 2] === CODEPOINTS["`"]) {
+                        i += 3;
+                        type = "code";
+                        let languageEnd = i;
+                        while (text[languageEnd] != null && !isWhitespace(text[languageEnd]) && text[languageEnd] !== CODEPOINTS["`"]) {
+                            languageEnd++;
+                        }
+                        if (i !== languageEnd && languageEnd < text.length && text[languageEnd] !== CODEPOINTS["`"]) {
+                            type = "pre";
+                            argument = text.slice(i, languageEnd);
+                            i = languageEnd;
+                        }
+                        const current = text[i], next = text[i + 1];
+                        if (current === CODEPOINTS["\n"] || current === CODEPOINTS["\r"]) {
+                            if ((next === CODEPOINTS["\n"] || next === CODEPOINTS["\r"]) && current !== next) {
+                                i += 2;
+                            }
+                            else {
+                                i++;
+                            }
+                        }
+                        i--;
+                    }
+                    else {
+                        type = "code";
+                    }
+                    break;
+                case CODEPOINTS["!"]:
+                    if (text[i + 1] === CODEPOINTS["["]) {
+                        i++;
+                        type = "customEmoji";
+                    }
+                    else {
+                        throw new Error(`Character '${String.fromCharCode(text[i])}' is reserved and must be escaped with the preceding '\\'`);
+                    }
+                    break;
+                default:
+                    throw new Error(`Character '${String.fromCharCode(text[i])}' is reserved and must be escaped with the preceding '\\'`);
+            }
+            nestedEntities.push({ type, argument, entityOffset: utf16Offset, entityByteOffset, entityBeginPos: resultSize });
+        }
+        else {
+            let { type, argument } = nestedEntities[nestedEntities.length - 1];
+            let userId = 0;
+            let customEmojiId = "";
+            let skipEntity = utf16Offset === nestedEntities.at(-1).entityOffset;
+            switch (type) {
+                case "bold":
+                case "italic":
+                case "code":
+                case "strikethrough":
+                    break;
+                case "underline":
+                case "spoiler":
+                    i++;
+                    break;
+                case "pre":
+                    i += 2;
+                    break;
+                case "textLink": {
+                    let url;
+                    if (text[i + 1] !== CODEPOINTS["("]) {
+                        url = text.slice(nestedEntities.at(-1).entityBeginPos, resultSize);
+                    }
+                    else {
+                        i += 2;
+                        const urlBeginPos = i;
+                        const url_ = [];
+                        while (i < text.length && text[i] !== CODEPOINTS[")"]) {
+                            if (text[i] === CODEPOINTS["\\"] && text[i + 1] > 0 && text[i + 1] <= 126) {
+                                url_.push(text[i + 1]);
+                                i += 2;
+                                continue;
+                            }
+                            url_.push(text[i++]);
+                        }
+                        url = Uint8Array.from(url_);
+                        if (text[i] !== CODEPOINTS[")"]) {
+                            throw new Error("Can't find end of a URL at byte offset " + urlBeginPos);
+                        }
+                    }
+                    userId = getLinkUserId(dec.decode(url));
+                    if (!userId) {
+                        const url_ = getUrl(dec.decode(url));
+                        if (!url_) {
+                            skipEntity = true;
+                        }
+                        else {
+                            argument = url_;
+                        }
+                    }
+                    break;
+                }
+                case "customEmoji": {
+                    if (text[i + 1] !== CODEPOINTS["("]) {
+                        throw new Error("Custom emoji entity must contain a tg://emoji URL");
+                    }
+                    i += 2;
+                    const url_ = [];
+                    const urlBeginPos = i;
+                    while (i < text.length && text[i] !== CODEPOINTS[")"]) {
+                        if (text[i] === CODEPOINTS["\\"] && text[i + 1] > 0 && text[i + 1] <= 126) {
+                            url_.push(text[i + 1]);
+                            i += 2;
+                            continue;
+                        }
+                        url_.push(text[i++]);
+                    }
+                    const url = Uint8Array.from(url_);
+                    if (text[i] !== CODEPOINTS[")"]) {
+                        throw new Error("Can't find end of a custom emoji URL at byte offset " + urlBeginPos);
+                    }
+                    customEmojiId = getLinkCustomEmojiId(dec.decode(url));
+                    break;
+                }
+                default:
+                    UNREACHABLE();
+            }
+            if (!skipEntity) {
+                const entityOffset = nestedEntities.at(-1).entityOffset;
+                const entityLength = utf16Offset - entityOffset;
+                if (userId) {
+                    entities.push({ type: "textMention", offset: entityOffset, length: entityLength, userId });
+                }
+                else if (customEmojiId) {
+                    entities.push({ type: "customEmoji", offset: entityOffset, length: entityLength, customEmojiId });
+                }
+                else if (type == "textLink") {
+                    entities.push({ type, offset: entityOffset, length: entityLength, url: typeof argument === "string" ? argument : dec.decode(argument) });
+                }
+                else if (type == "pre") {
+                    entities.push({ type, offset: entityOffset, length: entityLength, language: typeof argument === "string" ? argument : dec.decode(argument) });
+                }
+                else if (type != "customEmoji") {
+                    entities.push({ type, offset: entityOffset, length: entityLength });
+                }
+            }
+            nestedEntities.pop();
+        }
+    }
+    if (nestedEntities.length !== 0) {
+        const last = nestedEntities[nestedEntities.length - 1];
+        throw new Error(`Can't find end of ${last.type} entity at byte offset ${last.entityByteOffset}`);
+    }
+    entities = sortMessageEntities(entities);
+    return [dec.decode(text.slice(0, resultSize)), entities];
+}

package/esm/client/0_message.d.ts

@@ -5,5 +5,5 @@ export declare function unpackUnencryptedMessage(buffer: Uint8Array): {
     messageId: bigint;
     message: Uint8Array;
 };
-export declare function encryptMessage(message: Message_, authKey: Uint8Array, authKeyId: bigint, salt: bigint, sessionId: bigint): Promise<Uint8Array>;
+export declare function encryptMessage(message: Message_ | MessageContainer, authKey: Uint8Array, authKeyId: bigint, salt: bigint, sessionId: bigint): Promise<Uint8Array>;
 export declare function decryptMessage(buffer: Uint8Array, authKey: Uint8Array, authKeyId: bigint, _sessionId: bigint): Promise<Message_ | MessageContainer>;

package/esm/client/0_message.js

@@ -29,14 +29,10 @@ export function unpackUnencryptedMessage(buffer) {
     return { messageId, message };
 }
 export async function encryptMessage(message, authKey, authKeyId, salt, sessionId) {
-    const encoded = message.body[serialize]();
     const payloadWriter = new TLWriter();
     payloadWriter.writeInt64(salt);
     payloadWriter.writeInt64(sessionId);
-    payloadWriter.writeInt64(message.id);
-    payloadWriter.writeInt32(message.seqNo);
-    payloadWriter.writeInt32(encoded.length);
-    payloadWriter.write(encoded);
+    payloadWriter.write(message[serialize]());
     payloadWriter.write(new Uint8Array(mod(-(payloadWriter.buffer.length + 12), 16) + 12));
     const payload = payloadWriter.buffer;
     const messageKey = (await sha256(concat(authKey.subarray(88, 120), payload))).subarray(8, 24);
@@ -70,7 +66,8 @@ export async function decryptMessage(buffer, authKey, authKeyId, _sessionId) {
     plainReader = new TLReader(plainReader.read(length));
     const cid = plainReader.readInt32(false);
     if (cid == MessageContainer[id]) {
-        return MessageContainer.deserialize(plainReader.buffer);
+        const messages = MessageContainer.deserialize(plainReader.buffer);
+        return new MessageContainer(mid, seqno, messages);
     }
     else if (cid == RPCResult[id]) {
         const body = RPCResult.deserialize(plainReader.buffer);

package/esm/client/0_params.d.ts

@@ -153,6 +153,9 @@ export interface _ThumbnailCommon {
 }
 export interface SendDocumentParams extends _CaptionCommon, _ThumbnailCommon, _SpoilCommon, _UploadCommon, _SendCommon {
 }
+export interface SendStickerParams extends _UploadCommon, _SendCommon {
+    emoji?: string;
+}
 export interface SendVideoParams extends _CaptionCommon, _ThumbnailCommon, _SpoilCommon, _UploadCommon, _SendCommon {
     /** The duration of the video in seconds. */
     duration?: number;
@@ -307,3 +310,16 @@ export interface GetCreatedInviteLinksParams {
     afterDate?: Date;
     afterInviteLink?: string;
 }
+export interface StopPollParams {
+    replyMarkup?: ReplyMarkup;
+}
+export interface EditMessageLiveLocationParams {
+    /** The accuracy radius of the location in meters. Must be in the range of 0-1500. */
+    horizontalAccuracy?: number;
+    /** The direction which the user is moving towards. Must be in the range of 1-350. */
+    heading?: number;
+    /** The maximum distance for proximity alerts on approaching another chat member in meters. Must be in the range 1-100,000. */
+    proximityAlertRadius?: number;
+    /** The reply markup of the message. Bot-only. */
+    replyMarkup?: ReplyMarkup;
+}

package/esm/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>;
+}