teleproto 1.214.0

package/errors/Common.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Errors not related to the Telegram API itself
+ */
+import { Api } from "../tl";
+/**
+ * Occurs when a read operation was cancelled.
+ */
+export declare class ReadCancelledError extends Error {
+    constructor();
+}
+/**
+ * Occurs when a type is not found, for example,
+ * when trying to read a TLObject with an invalid constructor code.
+ */
+export declare class TypeNotFoundError extends Error {
+    invalidConstructorId: number;
+    remaining: Buffer;
+    constructor(invalidConstructorId: number, remaining: Buffer);
+}
+/**
+ * Occurs when using the TCP full mode and the checksum of a received
+ * packet doesn't match the expected checksum.
+ */
+export declare class InvalidChecksumError extends Error {
+    private checksum;
+    private validChecksum;
+    constructor(checksum: number, validChecksum: number);
+}
+/**
+ * Occurs when the buffer is invalid, and may contain an HTTP error code.
+ * For instance, 404 means "forgotten/broken authorization key", while
+ */
+export declare class InvalidBufferError extends Error {
+    code?: number;
+    payload: Buffer;
+    constructor(payload: Buffer);
+}
+/**
+ * Generic security error, mostly used when generating a new AuthKey.
+ */
+export declare class SecurityError extends Error {
+    constructor(...args: any[]);
+}
+/**
+ * Occurs when there's a hash mismatch between the decrypted CDN file
+ * and its expected hash.
+ */
+export declare class CdnFileTamperedError extends SecurityError {
+    constructor();
+}
+/**
+ * Occurs when handling a badMessageNotification
+ */
+export declare class BadMessageError extends Error {
+    static ErrorMessages: {
+        16: string;
+        17: string;
+        18: string;
+        19: string;
+        20: string;
+        32: string;
+        33: string;
+        34: string;
+        35: string;
+        48: string;
+        64: string;
+    };
+    private code;
+    private errorMessage;
+    constructor(request: Api.AnyRequest, code: number);
+}

package/errors/Common.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Errors not related to the Telegram API itself
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BadMessageError = exports.CdnFileTamperedError = exports.SecurityError = exports.InvalidBufferError = exports.InvalidChecksumError = exports.TypeNotFoundError = exports.ReadCancelledError = void 0;
+/**
+ * Occurs when a read operation was cancelled.
+ */
+class ReadCancelledError extends Error {
+    constructor() {
+        super("The read operation was cancelled.");
+    }
+}
+exports.ReadCancelledError = ReadCancelledError;
+/**
+ * Occurs when a type is not found, for example,
+ * when trying to read a TLObject with an invalid constructor code.
+ */
+class TypeNotFoundError extends Error {
+    constructor(invalidConstructorId, remaining) {
+        super(`Could not find a matching Constructor ID for the TLObject that was supposed to be
+        read with ID ${invalidConstructorId}. Most likely, a TLObject was trying to be read when
+         it should not be read. Remaining bytes: ${remaining.length}`);
+        if (typeof alert !== "undefined") {
+            alert(`Missing MTProto Entity: Please, make sure to add TL definition for ID ${invalidConstructorId}`);
+        }
+        this.invalidConstructorId = invalidConstructorId;
+        this.remaining = remaining;
+    }
+}
+exports.TypeNotFoundError = TypeNotFoundError;
+/**
+ * Occurs when using the TCP full mode and the checksum of a received
+ * packet doesn't match the expected checksum.
+ */
+class InvalidChecksumError extends Error {
+    constructor(checksum, validChecksum) {
+        super(`Invalid checksum (${checksum} when ${validChecksum} was expected). This packet should be skipped.`);
+        this.checksum = checksum;
+        this.validChecksum = validChecksum;
+    }
+}
+exports.InvalidChecksumError = InvalidChecksumError;
+/**
+ * Occurs when the buffer is invalid, and may contain an HTTP error code.
+ * For instance, 404 means "forgotten/broken authorization key", while
+ */
+class InvalidBufferError extends Error {
+    constructor(payload) {
+        let code = undefined;
+        if (payload.length === 4) {
+            code = -payload.readInt32LE(0);
+            super(`Invalid response buffer (HTTP code ${code})`);
+        }
+        else {
+            super(`Invalid response buffer (too short ${payload})`);
+        }
+        this.code = code;
+        this.payload = payload;
+    }
+}
+exports.InvalidBufferError = InvalidBufferError;
+/**
+ * Generic security error, mostly used when generating a new AuthKey.
+ */
+class SecurityError extends Error {
+    constructor(...args) {
+        if (!args.length) {
+            args = ["A security check failed."];
+        }
+        super(...args);
+    }
+}
+exports.SecurityError = SecurityError;
+/**
+ * Occurs when there's a hash mismatch between the decrypted CDN file
+ * and its expected hash.
+ */
+class CdnFileTamperedError extends SecurityError {
+    constructor() {
+        super("The CDN file has been altered and its download cancelled.");
+    }
+}
+exports.CdnFileTamperedError = CdnFileTamperedError;
+/**
+ * Occurs when handling a badMessageNotification
+ */
+class BadMessageError extends Error {
+    constructor(request, code) {
+        let errorMessage = BadMessageError.ErrorMessages[code] ||
+            `Unknown error code (this should not happen): ${code}.`;
+        errorMessage += `  Caused by ${request.className}`;
+        super(errorMessage);
+        this.errorMessage = errorMessage;
+        this.code = code;
+    }
+}
+exports.BadMessageError = BadMessageError;
+BadMessageError.ErrorMessages = {
+    16: "msg_id too low (most likely, client time is wrong it would be worthwhile to " +
+        "synchronize it using msg_id notifications and re-send the original message " +
+        "with the “correct” msg_id or wrap it in a container with a new msg_id if the " +
+        "original message had waited too long on the client to be transmitted).",
+    17: "msg_id too high (similar to the previous case, the client time has to be " +
+        "synchronized, and the message re-sent with the correct msg_id).",
+    18: "Incorrect two lower order msg_id bits (the server expects client message msg_id " +
+        "to be divisible by 4).",
+    19: "Container msg_id is the same as msg_id of a previously received message " +
+        "(this must never happen).",
+    20: "Message too old, and it cannot be verified whether the server has received a " +
+        "message with this msg_id or not.",
+    32: "msg_seqno too low (the server has already received a message with a lower " +
+        "msg_id but with either a higher or an equal and odd seqno).",
+    33: "msg_seqno too high (similarly, there is a message with a higher msg_id but with " +
+        "either a lower or an equal and odd seqno).",
+    34: "An even msg_seqno expected (irrelevant message), but odd received.",
+    35: "Odd msg_seqno expected (relevant message), but even received.",
+    48: "Incorrect server salt (in this case, the bad_server_salt response is received with " +
+        "the correct salt, and the message is to be re-sent with it).",
+    64: "Invalid container.",
+};

package/errors/RPCBaseErrors.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Base class for all Remote Procedure Call errors.
+ */
+import { Api } from "../tl";
+import { CustomError } from "ts-custom-error";
+export declare class RPCError extends CustomError {
+    code: number | undefined;
+    errorMessage: string;
+    constructor(message: string, request: Api.AnyRequest, code?: number);
+    static _fmtRequest(request: Api.AnyRequest): string;
+}
+/**
+ * The request must be repeated, but directed to a different data center.
+ */
+export declare class InvalidDCError extends RPCError {
+    constructor(message: string, request: Api.AnyRequest, code?: number);
+}
+/**
+ * The query contains errors. In the event that a request was created
+ * using a form and contains user generated data, the user should be
+ * notified that the data must be corrected before the query is repeated.
+ */
+export declare class BadRequestError extends RPCError {
+    code: number;
+    errorMessage: string;
+}
+/**
+ * There was an unauthorized attempt to use functionality available only
+ * to authorized users.
+ */
+export declare class UnauthorizedError extends RPCError {
+    code: number;
+    errorMessage: string;
+}
+/**
+ * Privacy violation. For example, an attempt to write a message to
+ * someone who has blacklisted the current user.
+ */
+export declare class ForbiddenError extends RPCError {
+    code: number;
+    errorMessage: string;
+}
+/**
+ * An attempt to invoke a non-existent object, such as a method.
+ */
+export declare class NotFoundError extends RPCError {
+    code: number;
+    errorMessage: string;
+}
+/**
+ * Errors related to invalid authorization key, like
+ * AUTH_KEY_DUPLICATED which can cause the connection to fail.
+ */
+export declare class AuthKeyError extends RPCError {
+    code: number;
+    errorMessage: string;
+}
+/**
+ * The maximum allowed number of attempts to invoke the given method
+ * with the given input parameters has been exceeded. For example, in an
+ * attempt to request a large number of text messages (SMS) for the same
+ * phone number.
+ */
+export declare class FloodError extends RPCError {
+    code: number;
+    errorMessage: string;
+}
+/**
+ * An internal server error occurred while a request was being processed
+ * for example, there was a disruption while accessing a database or file
+ * storage
+ */
+export declare class ServerError extends RPCError {
+    code: number;
+    errorMessage: string;
+}
+/**
+ * Clicking the inline buttons of bots that never (or take to long to)
+ * call ``answerCallbackQuery`` will result in this "special" RPCError.
+ */
+export declare class TimedOutError extends RPCError {
+    code: number;
+    errorMessage: string;
+}

package/errors/RPCBaseErrors.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimedOutError = exports.ServerError = exports.FloodError = exports.AuthKeyError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.InvalidDCError = exports.RPCError = void 0;
+const ts_custom_error_1 = require("ts-custom-error");
+class RPCError extends ts_custom_error_1.CustomError {
+    constructor(message, request, code) {
+        super("{0}: {1}{2}"
+            .replace("{0}", (code === null || code === void 0 ? void 0 : code.toString()) || "")
+            .replace("{1}", message || "")
+            .replace("{2}", RPCError._fmtRequest(request)));
+        this.code = code;
+        this.errorMessage = message;
+    }
+    static _fmtRequest(request) {
+        // TODO fix this
+        if (request) {
+            return ` (caused by ${request.className})`;
+        }
+        else {
+            return "";
+        }
+    }
+}
+exports.RPCError = RPCError;
+/**
+ * The request must be repeated, but directed to a different data center.
+ */
+class InvalidDCError extends RPCError {
+    constructor(message, request, code) {
+        super(message, request, code);
+        this.code = code || 303;
+        this.errorMessage = message || "ERROR_SEE_OTHER";
+    }
+}
+exports.InvalidDCError = InvalidDCError;
+/**
+ * The query contains errors. In the event that a request was created
+ * using a form and contains user generated data, the user should be
+ * notified that the data must be corrected before the query is repeated.
+ */
+class BadRequestError extends RPCError {
+    constructor() {
+        super(...arguments);
+        this.code = 400;
+        this.errorMessage = "BAD_REQUEST";
+    }
+}
+exports.BadRequestError = BadRequestError;
+/**
+ * There was an unauthorized attempt to use functionality available only
+ * to authorized users.
+ */
+class UnauthorizedError extends RPCError {
+    constructor() {
+        super(...arguments);
+        this.code = 401;
+        this.errorMessage = "UNAUTHORIZED";
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+/**
+ * Privacy violation. For example, an attempt to write a message to
+ * someone who has blacklisted the current user.
+ */
+class ForbiddenError extends RPCError {
+    constructor() {
+        super(...arguments);
+        this.code = 403;
+        this.errorMessage = "FORBIDDEN";
+    }
+}
+exports.ForbiddenError = ForbiddenError;
+/**
+ * An attempt to invoke a non-existent object, such as a method.
+ */
+class NotFoundError extends RPCError {
+    constructor() {
+        super(...arguments);
+        this.code = 404;
+        this.errorMessage = "NOT_FOUND";
+    }
+}
+exports.NotFoundError = NotFoundError;
+/**
+ * Errors related to invalid authorization key, like
+ * AUTH_KEY_DUPLICATED which can cause the connection to fail.
+ */
+class AuthKeyError extends RPCError {
+    constructor() {
+        super(...arguments);
+        this.code = 406;
+        this.errorMessage = "AUTH_KEY";
+    }
+}
+exports.AuthKeyError = AuthKeyError;
+/**
+ * The maximum allowed number of attempts to invoke the given method
+ * with the given input parameters has been exceeded. For example, in an
+ * attempt to request a large number of text messages (SMS) for the same
+ * phone number.
+ */
+class FloodError extends RPCError {
+    constructor() {
+        super(...arguments);
+        this.code = 420;
+        this.errorMessage = "FLOOD";
+    }
+}
+exports.FloodError = FloodError;
+/**
+ * An internal server error occurred while a request was being processed
+ * for example, there was a disruption while accessing a database or file
+ * storage
+ */
+class ServerError extends RPCError {
+    constructor() {
+        super(...arguments);
+        this.code = 500; // Also witnessed as -500
+        this.errorMessage = "INTERNAL";
+    }
+}
+exports.ServerError = ServerError;
+/**
+ * Clicking the inline buttons of bots that never (or take to long to)
+ * call ``answerCallbackQuery`` will result in this "special" RPCError.
+ */
+class TimedOutError extends RPCError {
+    constructor() {
+        super(...arguments);
+        this.code = 503; // Only witnessed as -503
+        this.errorMessage = "Timeout";
+    }
+}
+exports.TimedOutError = TimedOutError;

package/errors/RPCErrorList.d.ts

@@ -0,0 +1,37 @@
+import { InvalidDCError, FloodError, BadRequestError } from "./RPCBaseErrors";
+export declare class UserMigrateError extends InvalidDCError {
+    newDc: number;
+    constructor(args: any);
+}
+export declare class PhoneMigrateError extends InvalidDCError {
+    newDc: number;
+    constructor(args: any);
+}
+export declare class SlowModeWaitError extends FloodError {
+    seconds: number;
+    constructor(args: any);
+}
+export declare class FloodWaitError extends FloodError {
+    seconds: number;
+    constructor(args: any);
+}
+export declare class FloodTestPhoneWaitError extends FloodError {
+    seconds: number;
+    constructor(args: any);
+}
+export declare class FileMigrateError extends InvalidDCError {
+    newDc: number;
+    constructor(args: any);
+}
+export declare class NetworkMigrateError extends InvalidDCError {
+    newDc: number;
+    constructor(args: any);
+}
+export declare class EmailUnconfirmedError extends BadRequestError {
+    codeLength: number;
+    constructor(args: any);
+}
+export declare class MsgWaitError extends FloodError {
+    constructor(args: any);
+}
+export declare const rpcErrorRe: Map<RegExp, any>;

package/errors/RPCErrorList.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rpcErrorRe = exports.MsgWaitError = exports.EmailUnconfirmedError = exports.NetworkMigrateError = exports.FileMigrateError = exports.FloodTestPhoneWaitError = exports.FloodWaitError = exports.SlowModeWaitError = exports.PhoneMigrateError = exports.UserMigrateError = void 0;
+const RPCBaseErrors_1 = require("./RPCBaseErrors");
+class UserMigrateError extends RPCBaseErrors_1.InvalidDCError {
+    constructor(args) {
+        const newDc = Number(args.capture || 0);
+        super(`The user whose identity is being used to execute queries is associated with DC ${newDc}` +
+            RPCBaseErrors_1.RPCError._fmtRequest(args.request), args.request);
+        this.message =
+            `The user whose identity is being used to execute queries is associated with DC ${newDc}` +
+                RPCBaseErrors_1.RPCError._fmtRequest(args.request);
+        this.newDc = newDc;
+    }
+}
+exports.UserMigrateError = UserMigrateError;
+class PhoneMigrateError extends RPCBaseErrors_1.InvalidDCError {
+    constructor(args) {
+        const newDc = Number(args.capture || 0);
+        super(`The phone number a user is trying to use for authorization is associated with DC ${newDc}` +
+            RPCBaseErrors_1.RPCError._fmtRequest(args.request), args.request);
+        this.message =
+            `The phone number a user is trying to use for authorization is associated with DC ${newDc}` +
+                RPCBaseErrors_1.RPCError._fmtRequest(args.request);
+        this.newDc = newDc;
+    }
+}
+exports.PhoneMigrateError = PhoneMigrateError;
+class SlowModeWaitError extends RPCBaseErrors_1.FloodError {
+    constructor(args) {
+        const seconds = Number(args.capture || 0);
+        super(`A wait of ${seconds} seconds is required before sending another message in this chat` +
+            RPCBaseErrors_1.RPCError._fmtRequest(args.request), args.request);
+        this.message =
+            `A wait of ${seconds} seconds is required before sending another message in this chat` +
+                RPCBaseErrors_1.RPCError._fmtRequest(args.request);
+        this.seconds = seconds;
+    }
+}
+exports.SlowModeWaitError = SlowModeWaitError;
+class FloodWaitError extends RPCBaseErrors_1.FloodError {
+    constructor(args) {
+        const seconds = Number(args.capture || 0);
+        super(`A wait of ${seconds} seconds is required` +
+            RPCBaseErrors_1.RPCError._fmtRequest(args.request), args.request);
+        this.message =
+            `A wait of ${seconds} seconds is required` +
+                RPCBaseErrors_1.RPCError._fmtRequest(args.request);
+        this.seconds = seconds;
+    }
+}
+exports.FloodWaitError = FloodWaitError;
+class FloodTestPhoneWaitError extends RPCBaseErrors_1.FloodError {
+    constructor(args) {
+        const seconds = Number(args.capture || 0);
+        super(`A wait of ${seconds} seconds is required in the test servers` +
+            RPCBaseErrors_1.RPCError._fmtRequest(args.request), args.request);
+        this.message =
+            `A wait of ${seconds} seconds is required in the test servers` +
+                RPCBaseErrors_1.RPCError._fmtRequest(args.request);
+        this.seconds = seconds;
+    }
+}
+exports.FloodTestPhoneWaitError = FloodTestPhoneWaitError;
+class FileMigrateError extends RPCBaseErrors_1.InvalidDCError {
+    constructor(args) {
+        const newDc = Number(args.capture || 0);
+        super(`The file to be accessed is currently stored in DC ${newDc}` +
+            RPCBaseErrors_1.RPCError._fmtRequest(args.request), args.request);
+        this.message =
+            `The file to be accessed is currently stored in DC ${newDc}` +
+                RPCBaseErrors_1.RPCError._fmtRequest(args.request);
+        this.newDc = newDc;
+    }
+}
+exports.FileMigrateError = FileMigrateError;
+class NetworkMigrateError extends RPCBaseErrors_1.InvalidDCError {
+    constructor(args) {
+        const newDc = Number(args.capture || 0);
+        super(`The source IP address is associated with DC ${newDc}` +
+            RPCBaseErrors_1.RPCError._fmtRequest(args.request), args.request);
+        this.message =
+            `The source IP address is associated with DC ${newDc}` +
+                RPCBaseErrors_1.RPCError._fmtRequest(args.request);
+        this.newDc = newDc;
+    }
+}
+exports.NetworkMigrateError = NetworkMigrateError;
+class EmailUnconfirmedError extends RPCBaseErrors_1.BadRequestError {
+    constructor(args) {
+        const codeLength = Number(args.capture || 0);
+        super(`Email unconfirmed, the length of the code must be ${codeLength}${RPCBaseErrors_1.RPCError._fmtRequest(args.request)}`, args.request, 400);
+        // eslint-disable-next-line max-len
+        this.message = `Email unconfirmed, the length of the code must be ${codeLength}${RPCBaseErrors_1.RPCError._fmtRequest(args.request)}`;
+        this.codeLength = codeLength;
+    }
+}
+exports.EmailUnconfirmedError = EmailUnconfirmedError;
+class MsgWaitError extends RPCBaseErrors_1.FloodError {
+    constructor(args) {
+        super(`Message failed to be sent.${RPCBaseErrors_1.RPCError._fmtRequest(args.request)}`, args.request);
+        this.message = `Message failed to be sent.${RPCBaseErrors_1.RPCError._fmtRequest(args.request)}`;
+    }
+}
+exports.MsgWaitError = MsgWaitError;
+exports.rpcErrorRe = new Map([
+    [/FILE_MIGRATE_(\d+)/, FileMigrateError],
+    [/FLOOD_TEST_PHONE_WAIT_(\d+)/, FloodTestPhoneWaitError],
+    [/FLOOD_WAIT_(\d+)/, FloodWaitError],
+    [/FLOOD_PREMIUM_WAIT_(\d+)/, FloodWaitError],
+    [/MSG_WAIT_(.*)/, MsgWaitError],
+    [/PHONE_MIGRATE_(\d+)/, PhoneMigrateError],
+    [/SLOWMODE_WAIT_(\d+)/, SlowModeWaitError],
+    [/USER_MIGRATE_(\d+)/, UserMigrateError],
+    [/NETWORK_MIGRATE_(\d+)/, NetworkMigrateError],
+    [/EMAIL_UNCONFIRMED_(\d+)/, EmailUnconfirmedError],
+]);

package/errors/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Converts a Telegram's RPC Error to a Python error.
+ * @param rpcError the RPCError instance
+ * @param request the request that caused this error
+ * @constructor the RPCError as a Python exception that represents this error
+ */
+import { Api } from "../tl";
+export declare function RPCMessageToError(rpcError: Api.RpcError, request: Api.AnyRequest): any;
+export * from "./Common";
+export * from "./RPCBaseErrors";
+export * from "./RPCErrorList";

package/errors/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPCMessageToError = RPCMessageToError;
+const RPCBaseErrors_1 = require("./RPCBaseErrors");
+const RPCErrorList_1 = require("./RPCErrorList");
+function RPCMessageToError(rpcError, request) {
+    for (const [msgRegex, Cls] of RPCErrorList_1.rpcErrorRe) {
+        const m = rpcError.errorMessage.match(msgRegex);
+        if (m) {
+            const capture = m.length === 2 ? parseInt(m[1]) : null;
+            return new Cls({ request: request, capture: capture });
+        }
+    }
+    return new RPCBaseErrors_1.RPCError(rpcError.errorMessage, request, rpcError.errorCode);
+}
+__exportStar(require("./Common"), exports);
+__exportStar(require("./RPCBaseErrors"), exports);
+__exportStar(require("./RPCErrorList"), exports);

package/events/Album.d.ts

@@ -0,0 +1,36 @@
+import { DefaultEventInterface, EventBuilder, EventCommon } from "./common";
+import { Entity } from "../define";
+import { Api } from "../tl";
+import { TelegramClient } from "..";
+/**
+ * Occurs whenever an album (multiple grouped messages with media) arrive.
+ * @example
+ * ```ts
+ * // Albums are basically a list of messages. so event is a list
+ *   async function listenForAlbums(event: AlbumEvent) {
+ *       const messages = event.messages;
+ *       for (const message of messages){
+ *           console.log("Caption is",message.text);
+ *           console.log("Message id is",message.id);
+ *           console.log("Chat id is",message.chatId);
+ *       }
+ *   }
+ * // adds an event handler for new messages
+ * client.addEventHandler(listenForAlbums, new Album({}));
+ * ```
+ */
+export declare class Album extends EventBuilder {
+    func?: {
+        (event: Album): boolean;
+    };
+    constructor(albumParams: DefaultEventInterface);
+    build(update: Api.TypeUpdate, dispatch?: CallableFunction): any;
+}
+export declare class AlbumEvent extends EventCommon {
+    messages: Api.Message[];
+    originalUpdates: (Api.TypeUpdate & {
+        _entities?: Map<string, Entity>;
+    })[];
+    constructor(messages: Api.Message[], originalUpdates: Api.TypeUpdate[]);
+    _setClient(client: TelegramClient): void;
+}