teleproto 1.221.2 → 1.221.3

package/Version.d.ts

@@ -1 +1 @@
-export declare const version = "1.221.2";
+export declare const version = "1.221.3";

package/Version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-exports.version = "1.221.2";
+exports.version = "1.221.3";

package/client/TelegramClient.d.ts

@@ -161,10 +161,62 @@ export declare class TelegramClient extends TelegramBaseClient {
      * @param reCaptchaCallback - callback to handle reCAPTCHA verification
      * @return the phone code hash and whether it was sent via app
      */
-    sendCode(apiCredentials: authMethods.ApiCredentials, phoneNumber: string, forceSMS?: boolean, reCaptchaCallback?: (siteKey: string) => Promise<string>): Promise<{
-        phoneCodeHash: string;
-        isCodeViaApp: boolean;
-    }>;
+    sendCode(apiCredentials: authMethods.ApiCredentials, phoneNumber: string, forceSMS?: boolean, reCaptchaCallback?: (siteKey: string) => Promise<string>): Promise<authMethods.SendCodeResult>;
+    /**
+     * Sends an email verification code for login setup.
+     * This is used when Telegram requires email verification during login.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @param email - The email address to verify
+     * @returns The email pattern and code length
+     * @example
+     * ```ts
+     * const result = await client.sendVerifyEmailCode(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     "user@example.com"
+     * );
+     * console.log(`Code sent to ${result.emailPattern}, length: ${result.length}`);
+     * ```
+     */
+    sendVerifyEmailCode(phoneNumber: string, phoneCodeHash: string, email: string): Promise<authMethods.SentEmailCodeResult>;
+    /**
+     * Verifies an email address during login setup.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @param verification - The verification result (code, Google token, or Apple token)
+     * @returns The verified email and the new sent code for phone verification
+     * @example
+     * ```ts
+     * // Verify with email code
+     * const result = await client.verifyEmail(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     { type: "code", code: "12345" }
+     * );
+     *
+     * // Or verify with Google Sign-In
+     * const result = await client.verifyEmail(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     { type: "google", token: "google-id-token" }
+     * );
+     * ```
+     */
+    verifyEmail(phoneNumber: string, phoneCodeHash: string, verification: authMethods.EmailVerificationResult): Promise<authMethods.EmailVerifiedLoginResult>;
+    /**
+     * Resets the login email when the user cannot access their current email.
+     * This will cancel the current email verification and allow setting up a new one.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @returns The new sent code result
+     * @example
+     * ```ts
+     * // User can't access their email, reset it
+     * const newSentCode = await client.resetLoginEmail("+1234567890", "abc123hash");
+     * ```
+     */
+    resetLoginEmail(phoneNumber: string, phoneCodeHash: string): Promise<Api.auth.TypeSentCode>;
     /**
      * Uses the 2FA password to sign in the account.<br/>
      * This function should be used after the user has signed in with the code they received.

package/client/TelegramClient.js

@@ -211,6 +211,67 @@ class TelegramClient extends telegramBaseClient_1.TelegramBaseClient {
     sendCode(apiCredentials, phoneNumber, forceSMS = false, reCaptchaCallback) {
         return authMethods.sendCode(this, apiCredentials, phoneNumber, forceSMS, reCaptchaCallback);
     }
+    /**
+     * Sends an email verification code for login setup.
+     * This is used when Telegram requires email verification during login.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @param email - The email address to verify
+     * @returns The email pattern and code length
+     * @example
+     * ```ts
+     * const result = await client.sendVerifyEmailCode(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     "user@example.com"
+     * );
+     * console.log(`Code sent to ${result.emailPattern}, length: ${result.length}`);
+     * ```
+     */
+    sendVerifyEmailCode(phoneNumber, phoneCodeHash, email) {
+        return authMethods.sendVerifyEmailCode(this, phoneNumber, phoneCodeHash, email);
+    }
+    /**
+     * Verifies an email address during login setup.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @param verification - The verification result (code, Google token, or Apple token)
+     * @returns The verified email and the new sent code for phone verification
+     * @example
+     * ```ts
+     * // Verify with email code
+     * const result = await client.verifyEmail(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     { type: "code", code: "12345" }
+     * );
+     *
+     * // Or verify with Google Sign-In
+     * const result = await client.verifyEmail(
+     *     "+1234567890",
+     *     "abc123hash",
+     *     { type: "google", token: "google-id-token" }
+     * );
+     * ```
+     */
+    verifyEmail(phoneNumber, phoneCodeHash, verification) {
+        return authMethods.verifyEmail(this, phoneNumber, phoneCodeHash, verification);
+    }
+    /**
+     * Resets the login email when the user cannot access their current email.
+     * This will cancel the current email verification and allow setting up a new one.
+     * @param phoneNumber - The phone number being used for login
+     * @param phoneCodeHash - The phone code hash from sendCode
+     * @returns The new sent code result
+     * @example
+     * ```ts
+     * // User can't access their email, reset it
+     * const newSentCode = await client.resetLoginEmail("+1234567890", "abc123hash");
+     * ```
+     */
+    resetLoginEmail(phoneNumber, phoneCodeHash) {
+        return authMethods.resetLoginEmail(this, phoneNumber, phoneCodeHash);
+    }
     /**
      * Uses the 2FA password to sign in the account.<br/>
      * This function should be used after the user has signed in with the code they received.

package/client/auth.d.ts

@@ -1,5 +1,35 @@
 import { Api } from "../tl";
 import type { TelegramClient } from "./TelegramClient";
+/**
+ * Email verification options passed to the email callback.
+ */
+export interface EmailVerificationOptions {
+    /** Whether Google Sign-In is allowed for email verification. */
+    googleSigninAllowed?: boolean;
+    /** Whether Apple Sign-In is allowed for email verification. */
+    appleSigninAllowed?: boolean;
+    /** The email pattern (masked email) when code was sent to existing email. */
+    emailPattern?: string;
+    /** The code length when email code is expected. */
+    codeLength?: number;
+    /** Period in seconds after which the email can be reset. */
+    resetAvailablePeriod?: number;
+    /** Date when the pending reset will complete. */
+    resetPendingDate?: number;
+}
+/**
+ * Result from the email callback - can be code, Google token, or Apple token.
+ */
+export type EmailVerificationResult = {
+    type: "code";
+    code: string;
+} | {
+    type: "google";
+    token: string;
+} | {
+    type: "apple";
+    token: string;
+};
 /**
  * For when you want to login as a {@link Api.User}<br/>
  * this should handle all needed steps for authorization as a user.<br/>
@@ -29,6 +59,14 @@ export interface UserAuthParams {
     forceSMS?: boolean;
     /** optional callback for handling reCAPTCHA. */
     reCaptchaCallback?: (siteKey: string) => Promise<string>;
+    /** callback for email verification when Telegram requires email setup or code.<br/>
+     *  Called when `auth.SentCodeTypeSetUpEmailRequired` or `auth.SentCodeTypeEmailCode` is received.<br/>
+     *  For setup: should return email address to use and then handle verification code.<br/>
+     *  For existing email: should return the verification result (code, Google token, or Apple token). */
+    emailVerification?: (options: EmailVerificationOptions) => Promise<EmailVerificationResult>;
+    /** callback to get email address when email setup is required.<br/>
+     *  Called first when `auth.SentCodeTypeSetUpEmailRequired` is received. */
+    emailAddress?: () => Promise<string>;
 }
 export interface UserPasswordAuthParams {
     /** optional string or callback that should return the 2FA password if present.<br/>
@@ -80,16 +118,75 @@ export declare function checkAuthorization(client: TelegramClient): Promise<bool
 export declare function signInUser(client: TelegramClient, apiCredentials: ApiCredentials, authParams: UserAuthParams): Promise<Api.TypeUser>;
 /** @hidden */
 export declare function signInUserWithQrCode(client: TelegramClient, apiCredentials: ApiCredentials, authParams: QrCodeAuthParams): Promise<Api.TypeUser>;
-/** @hidden */
-/** @hidden */
-export declare function sendCode(client: TelegramClient, apiCredentials: ApiCredentials, phoneNumber: string, forceSMS?: boolean, reCaptchaCallback?: (siteKey: string) => Promise<string>): Promise<{
+/**
+ * Result from sendCode containing info about how to proceed with verification.
+ */
+export interface SendCodeResult {
+    /** The phone code hash needed for sign in. */
     phoneCodeHash: string;
+    /** Whether the code was sent via Telegram app (true) or SMS (false). */
     isCodeViaApp: boolean;
-}>;
+    /** If true, email setup is required before phone code. */
+    emailRequired?: boolean;
+    /** If true, code was sent to existing email. */
+    emailCodeSent?: boolean;
+    /** Email verification options when email is involved. */
+    emailOptions?: EmailVerificationOptions;
+}
+/** @hidden */
+export declare function sendCode(client: TelegramClient, apiCredentials: ApiCredentials, phoneNumber: string, forceSMS?: boolean, reCaptchaCallback?: (siteKey: string) => Promise<string>): Promise<SendCodeResult>;
 /** @hidden */
 export declare function signInWithPassword(client: TelegramClient, apiCredentials: ApiCredentials, authParams: UserPasswordAuthParams): Promise<Api.TypeUser>;
 /** @hidden */
 export declare function signInBot(client: TelegramClient, apiCredentials: ApiCredentials, authParams: BotAuthParams): Promise<Api.TypeUser>;
 /** @hidden */
 export declare function _authFlow(client: TelegramClient, apiCredentials: ApiCredentials, authParams: UserAuthParams | BotAuthParams): Promise<void>;
+/**
+ * Result from sendVerifyEmailCode.
+ */
+export interface SentEmailCodeResult {
+    /** The masked email pattern where the code was sent. */
+    emailPattern: string;
+    /** The length of the verification code. */
+    length: number;
+}
+/**
+ * Sends an email verification code for login setup.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @param email - The email address to verify
+ * @returns The email pattern and code length
+ */
+/** @hidden */
+export declare function sendVerifyEmailCode(client: TelegramClient, phoneNumber: string, phoneCodeHash: string, email: string): Promise<SentEmailCodeResult>;
+/**
+ * Result from verifyEmail for login.
+ */
+export interface EmailVerifiedLoginResult {
+    /** The verified email address. */
+    email: string;
+    /** The new sent code result to continue with phone verification. */
+    sentCode: Api.auth.TypeSentCode;
+}
+/**
+ * Verifies an email address during login setup.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @param verification - The verification (code, Google token, or Apple token)
+ * @returns The verified email and the new sent code for phone verification
+ */
+/** @hidden */
+export declare function verifyEmail(client: TelegramClient, phoneNumber: string, phoneCodeHash: string, verification: EmailVerificationResult): Promise<EmailVerifiedLoginResult>;
+/**
+ * Resets the login email when the user cannot access their current email.
+ * This will cancel the current email verification and allow setting up a new one.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @returns The new sent code result
+ */
+/** @hidden */
+export declare function resetLoginEmail(client: TelegramClient, phoneNumber: string, phoneCodeHash: string): Promise<Api.auth.TypeSentCode>;
 export {};

package/client/auth.js

@@ -41,6 +41,9 @@ exports.sendCode = sendCode;
 exports.signInWithPassword = signInWithPassword;
 exports.signInBot = signInBot;
 exports._authFlow = _authFlow;
+exports.sendVerifyEmailCode = sendVerifyEmailCode;
+exports.verifyEmail = verifyEmail;
+exports.resetLoginEmail = resetLoginEmail;
 const tl_1 = require("../tl");
 const utils = __importStar(require("../Utils"));
 const Helpers_1 = require("../Helpers");
@@ -73,8 +76,8 @@ async function checkAuthorization(client) {
 }
 /** @hidden */
 async function signInUser(client, apiCredentials, authParams) {
-    let phoneNumber;
-    let phoneCodeHash;
+    let phoneNumber = "";
+    let phoneCodeHash = "";
     let isCodeViaApp = false;
     while (1) {
         try {
@@ -98,6 +101,45 @@ async function signInUser(client, apiCredentials, authParams) {
             if (typeof phoneCodeHash !== "string") {
                 throw new Error("Failed to retrieve phone code hash");
             }
+            // Handle email verification if required
+            if (sendCodeResult.emailRequired) {
+                // Email setup is required before phone code
+                if (!authParams.emailAddress || !authParams.emailVerification) {
+                    throw new Error("Email verification required but emailAddress or emailVerification callback not provided");
+                }
+                // Get email address from user
+                const email = await authParams.emailAddress();
+                // Send verification code to email
+                const emailCodeResult = await sendVerifyEmailCode(client, phoneNumber, phoneCodeHash, email);
+                // Get verification from user
+                const verification = await authParams.emailVerification(Object.assign(Object.assign({}, sendCodeResult.emailOptions), { emailPattern: emailCodeResult.emailPattern, codeLength: emailCodeResult.length }));
+                // Verify email
+                const verifyResult = await verifyEmail(client, phoneNumber, phoneCodeHash, verification);
+                // Update phone code hash from the new sent code
+                if (verifyResult.sentCode instanceof tl_1.Api.auth.SentCode) {
+                    phoneCodeHash = verifyResult.sentCode.phoneCodeHash;
+                    isCodeViaApp =
+                        verifyResult.sentCode.type instanceof
+                            tl_1.Api.auth.SentCodeTypeApp;
+                }
+            }
+            else if (sendCodeResult.emailCodeSent) {
+                // Code was sent to existing email
+                if (!authParams.emailVerification) {
+                    throw new Error("Email code sent but emailVerification callback not provided");
+                }
+                // Get verification from user for existing email
+                const verification = await authParams.emailVerification(sendCodeResult.emailOptions || {});
+                // Verify with existing email
+                const verifyResult = await verifyEmail(client, phoneNumber, phoneCodeHash, verification);
+                // Update phone code hash from the new sent code
+                if (verifyResult.sentCode instanceof tl_1.Api.auth.SentCode) {
+                    phoneCodeHash = verifyResult.sentCode.phoneCodeHash;
+                    isCodeViaApp =
+                        verifyResult.sentCode.type instanceof
+                            tl_1.Api.auth.SentCodeTypeApp;
+                }
+            }
             break;
         }
         catch (err) {
@@ -273,7 +315,6 @@ async function signInUserWithQrCode(client, apiCredentials, authParams) {
     throw new Error("QR auth failed");
 }
 /** @hidden */
-/** @hidden */
 async function sendCode(client, apiCredentials, phoneNumber, forceSMS = false, reCaptchaCallback) {
     var _a;
     try {
@@ -310,6 +351,33 @@ async function sendCode(client, apiCredentials, phoneNumber, forceSMS = false, r
                 isCodeViaApp: false,
             };
         }
+        // Handle email verification types
+        if (sendResult.type instanceof tl_1.Api.auth.SentCodeTypeSetUpEmailRequired) {
+            return {
+                phoneCodeHash: sendResult.phoneCodeHash,
+                isCodeViaApp: false,
+                emailRequired: true,
+                emailOptions: {
+                    googleSigninAllowed: sendResult.type.googleSigninAllowed,
+                    appleSigninAllowed: sendResult.type.appleSigninAllowed,
+                },
+            };
+        }
+        if (sendResult.type instanceof tl_1.Api.auth.SentCodeTypeEmailCode) {
+            return {
+                phoneCodeHash: sendResult.phoneCodeHash,
+                isCodeViaApp: false,
+                emailCodeSent: true,
+                emailOptions: {
+                    googleSigninAllowed: sendResult.type.googleSigninAllowed,
+                    appleSigninAllowed: sendResult.type.appleSigninAllowed,
+                    emailPattern: sendResult.type.emailPattern,
+                    codeLength: sendResult.type.length,
+                    resetAvailablePeriod: sendResult.type.resetAvailablePeriod,
+                    resetPendingDate: sendResult.type.resetPendingDate,
+                },
+            };
+        }
         // If we already sent a SMS, do not resend the phoneCode (hash may be empty)
         if (!forceSMS || sendResult.type instanceof tl_1.Api.auth.SentCodeTypeSms) {
             return {
@@ -329,6 +397,33 @@ async function sendCode(client, apiCredentials, phoneNumber, forceSMS = false, r
                 isCodeViaApp: false,
             };
         }
+        // Handle email types in resend result as well
+        if (resendResult.type instanceof tl_1.Api.auth.SentCodeTypeSetUpEmailRequired) {
+            return {
+                phoneCodeHash: resendResult.phoneCodeHash,
+                isCodeViaApp: false,
+                emailRequired: true,
+                emailOptions: {
+                    googleSigninAllowed: resendResult.type.googleSigninAllowed,
+                    appleSigninAllowed: resendResult.type.appleSigninAllowed,
+                },
+            };
+        }
+        if (resendResult.type instanceof tl_1.Api.auth.SentCodeTypeEmailCode) {
+            return {
+                phoneCodeHash: resendResult.phoneCodeHash,
+                isCodeViaApp: false,
+                emailCodeSent: true,
+                emailOptions: {
+                    googleSigninAllowed: resendResult.type.googleSigninAllowed,
+                    appleSigninAllowed: resendResult.type.appleSigninAllowed,
+                    emailPattern: resendResult.type.emailPattern,
+                    codeLength: resendResult.type.length,
+                    resetAvailablePeriod: resendResult.type.resetAvailablePeriod,
+                    resetPendingDate: resendResult.type.resetPendingDate,
+                },
+            };
+        }
         return {
             phoneCodeHash: resendResult.phoneCodeHash,
             isCodeViaApp: resendResult.type instanceof tl_1.Api.auth.SentCodeTypeApp,
@@ -406,3 +501,83 @@ async function _authFlow(client, apiCredentials, authParams) {
         : await client.signInBot(apiCredentials, authParams);
     client._log.info("Signed in successfully as " + utils.getDisplayName(me));
 }
+/**
+ * Sends an email verification code for login setup.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @param email - The email address to verify
+ * @returns The email pattern and code length
+ */
+/** @hidden */
+async function sendVerifyEmailCode(client, phoneNumber, phoneCodeHash, email) {
+    const result = await client.invoke(new tl_1.Api.account.SendVerifyEmailCode({
+        purpose: new tl_1.Api.EmailVerifyPurposeLoginSetup({
+            phoneNumber,
+            phoneCodeHash,
+        }),
+        email,
+    }));
+    return {
+        emailPattern: result.emailPattern,
+        length: result.length,
+    };
+}
+/**
+ * Verifies an email address during login setup.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @param verification - The verification (code, Google token, or Apple token)
+ * @returns The verified email and the new sent code for phone verification
+ */
+/** @hidden */
+async function verifyEmail(client, phoneNumber, phoneCodeHash, verification) {
+    let emailVerification;
+    switch (verification.type) {
+        case "code":
+            emailVerification = new tl_1.Api.EmailVerificationCode({
+                code: verification.code,
+            });
+            break;
+        case "google":
+            emailVerification = new tl_1.Api.EmailVerificationGoogle({
+                token: verification.token,
+            });
+            break;
+        case "apple":
+            emailVerification = new tl_1.Api.EmailVerificationApple({
+                token: verification.token,
+            });
+            break;
+    }
+    const result = await client.invoke(new tl_1.Api.account.VerifyEmail({
+        purpose: new tl_1.Api.EmailVerifyPurposeLoginSetup({
+            phoneNumber,
+            phoneCodeHash,
+        }),
+        verification: emailVerification,
+    }));
+    if (!(result instanceof tl_1.Api.account.EmailVerifiedLogin)) {
+        throw new Error("Expected EmailVerifiedLogin but got " + result.className);
+    }
+    return {
+        email: result.email,
+        sentCode: result.sentCode,
+    };
+}
+/**
+ * Resets the login email when the user cannot access their current email.
+ * This will cancel the current email verification and allow setting up a new one.
+ * @param client - The telegram client
+ * @param phoneNumber - The phone number being used for login
+ * @param phoneCodeHash - The phone code hash from sendCode
+ * @returns The new sent code result
+ */
+/** @hidden */
+async function resetLoginEmail(client, phoneNumber, phoneCodeHash) {
+    return await client.invoke(new tl_1.Api.auth.ResetLoginEmail({
+        phoneNumber,
+        phoneCodeHash,
+    }));
+}

package/client/updates.js

@@ -168,7 +168,7 @@ async function _updateLoop(client) {
     let lastPongAt;
     while (!client._destroyed) {
         await (0, Helpers_1.sleep)(PING_INTERVAL, true);
-        if (client._destroyed)
+        if (client._destroyed || client.disconnected)
             break;
         if (client._sender.isReconnecting || client._isSwitchingDc) {
             lastPongAt = undefined;
@@ -212,6 +212,9 @@ async function _updateLoop(client) {
                 console.error(err);
             }
             lastPongAt = undefined;
+            if (client.disconnected || client._destroyed) {
+                break;
+            }
             if (client._sender.isReconnecting || client._isSwitchingDc) {
                 continue;
             }

package/client/uploads.d.ts

@@ -130,7 +130,7 @@ export declare function _fileToMedia(client: TelegramClient, { file, forceDocume
     image?: boolean;
 }>;
 /** @hidden */
-export declare function _sendAlbum(client: TelegramClient, entity: EntityLike, { file, caption, forceDocument, fileSize, clearDraft, progressCallback, replyTo, attributes, thumb, parseMode, voiceNote, videoNote, silent, supportsStreaming, scheduleDate, workers, noforwards, commentTo, topMsgId, }: SendFileInterface): Promise<Api.Message>;
+export declare function _sendAlbum(client: TelegramClient, entity: EntityLike, { file, caption, formattingEntities, forceDocument, fileSize, clearDraft, progressCallback, replyTo, attributes, thumb, parseMode, voiceNote, videoNote, silent, supportsStreaming, scheduleDate, workers, noforwards, commentTo, topMsgId, }: SendFileInterface): Promise<Api.Message>;
 /** @hidden */
 export declare function sendFile(client: TelegramClient, entity: EntityLike, { file, caption, forceDocument, fileSize, clearDraft, progressCallback, replyTo, attributes, thumb, parseMode, formattingEntities, voiceNote, videoNote, buttons, silent, supportsStreaming, scheduleDate, workers, noforwards, commentTo, topMsgId, }: SendFileInterface): Promise<Api.Message>;
 export {};

package/client/uploads.js

@@ -318,7 +318,7 @@ async function _fileToMedia(client, { file, forceDocument, fileSize, progressCal
     };
 }
 /** @hidden */
-async function _sendAlbum(client, entity, { file, caption, forceDocument = false, fileSize, clearDraft = false, progressCallback, replyTo, attributes, thumb, parseMode, voiceNote = false, videoNote = false, silent, supportsStreaming = false, scheduleDate, workers = 1, noforwards, commentTo, topMsgId, }) {
+async function _sendAlbum(client, entity, { file, caption, formattingEntities, forceDocument = false, fileSize, clearDraft = false, progressCallback, replyTo, attributes, thumb, parseMode, voiceNote = false, videoNote = false, silent, supportsStreaming = false, scheduleDate, workers = 1, noforwards, commentTo, topMsgId, }) {
     entity = await client.getInputEntity(entity);
     let files = [];
     if (!Array.isArray(file)) {
@@ -334,8 +334,13 @@ async function _sendAlbum(client, entity, { file, caption, forceDocument = false
         caption = [caption];
     }
     const captions = [];
-    for (const c of caption) {
-        captions.push(await (0, messageParse_1._parseMessageText)(client, c, parseMode));
+    for (const [i, c] of caption.entries()) {
+        if (i === 0 && formattingEntities) {
+            captions.push([c || "", formattingEntities]);
+        }
+        else {
+            captions.push(await (0, messageParse_1._parseMessageText)(client, c, parseMode));
+        }
     }
     if (commentTo != undefined) {
         const discussionData = await (0, messages_1.getCommentData)(client, entity, commentTo);
@@ -440,6 +445,7 @@ async function sendFile(client, entity, { file, caption, forceDocument = false,
         return await _sendAlbum(client, entity, {
             file: file,
             caption: caption,
+            formattingEntities: formattingEntities,
             replyTo: replyTo,
             parseMode: parseMode,
             attributes: attributes,

package/index.d.ts

@@ -11,4 +11,5 @@ import * as extensions from "./extensions";
 import * as helpers from "./Helpers";
 import * as client from "./client";
 import * as password from "./Password";
-export { utils, errors, sessions, extensions, helpers, tl, password, client };
+import * as events from "./events";
+export { utils, errors, sessions, extensions, helpers, tl, password, client, events };

package/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.client = exports.password = exports.tl = exports.helpers = exports.extensions = exports.sessions = exports.errors = exports.utils = exports.Logger = exports.version = exports.Connection = exports.TelegramClient = exports.Api = void 0;
+exports.events = exports.client = exports.password = exports.tl = exports.helpers = exports.extensions = exports.sessions = exports.errors = exports.utils = exports.Logger = exports.version = exports.Connection = exports.TelegramClient = exports.Api = void 0;
 var tl_1 = require("./tl");
 Object.defineProperty(exports, "Api", { enumerable: true, get: function () { return tl_1.Api; } });
 const tl = __importStar(require("./tl"));
@@ -60,3 +60,5 @@ const client = __importStar(require("./client"));
 exports.client = client;
 const password = __importStar(require("./Password"));
 exports.password = password;
+const events = __importStar(require("./events"));
+exports.events = events;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teleproto",
-  "version": "1.221.2",
+  "version": "1.221.3",
   "description": "NodeJS MTProto API Telegram client library,",
   "main": "index.js",
   "types": "index.d.ts",