@mtkruto/browser 0.1.500 → 0.1.700

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

@@ -18,7 +18,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import { ID } from "../3_types.js";
-import { C } from "./0_types.js";
+import { C } from "./1_types.js";
 export declare class AccountManager {
     #private;
     constructor(c: C);

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

@@ -19,7 +19,7 @@
  */
 import { BotCommand } from "../3_types.js";
 import { GetMyCommandsParams, SetMyCommandsParams } from "./0_params.js";
-import { C } from "./0_types.js";
+import { C } from "./1_types.js";
 export declare class BotInfoManager {
     #private;
     constructor(c: C);

package/esm/client/{1_business_connection_manager.d.ts → 2_business_connection_manager.d.ts}

@@ -19,7 +19,7 @@
  */
 import { enums, types } from "../2_tl.js";
 import { Update } from "../3_types.js";
-import { C } from "./0_types.js";
+import { C } from "./1_types.js";
 export type BusinessConnectionManagerUpdate = types.UpdateBotBusinessConnect;
 export declare class BusinessConnectionManager {
     #private;

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

@@ -17,14 +17,18 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import { types } from "../2_tl.js";
+import { enums, types } from "../2_tl.js";
 import { FileSource, Sticker } from "../3_types.js";
 import { DownloadParams, UploadParams } from "./0_params.js";
-import { C } from "./0_types.js";
+import { C } from "./1_types.js";
 export declare class FileManager {
     #private;
     constructor(c: C);
     upload(file: FileSource, params?: UploadParams, checkName?: null | ((name: string) => string), allowStream?: boolean): Promise<import("../tl/2_types.js").InputFile_ | import("../tl/2_types.js").InputFileBig_>;
+    downloadInner(location: enums.InputFileLocation, dcId: number, params?: {
+        chunkSize?: number;
+        offset?: number;
+    }): AsyncGenerator<Uint8Array, void, unknown>;
     static validateChunkSize(chunkSize: number, max: number): void;
     download(fileId: string, params?: DownloadParams): AsyncGenerator<Uint8Array, void, unknown>;
     getStickerSetName(inputStickerSet: types.InputStickerSetID, hash?: number): Promise<string>;

package/esm/client/{1_file_manager.js → 2_file_manager.js}

@@ -28,8 +28,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _FileManager_instances, _a, _FileManager_c, _FileManager_Lupload, _FileManager_UPLOAD_MAX_CHUNK_SIZE, _FileManager_DOWNLOAD_MAX_CHUNK_SIZE, _FileManager_BIG_FILE_THRESHOLD, _FileManager_UPLOAD_REQUEST_PER_CONNECTION, _FileManager_uploadStream, _FileManager_uploadBuffer, _FileManager_handleUploadError, _FileManager_getFileContents, _FileManager_downloadInner, _FileManager_CUSTOM_EMOJI_TTL;
-import { assert, extension, path, unreachable } from "../0_deps.js";
+var _FileManager_instances, _a, _FileManager_c, _FileManager_Lupload, _FileManager_UPLOAD_MAX_CHUNK_SIZE, _FileManager_DOWNLOAD_MAX_CHUNK_SIZE, _FileManager_BIG_FILE_THRESHOLD, _FileManager_UPLOAD_REQUEST_PER_CONNECTION, _FileManager_uploadStream, _FileManager_uploadBuffer, _FileManager_handleUploadError, _FileManager_getFileContents, _FileManager_CUSTOM_EMOJI_TTL;
+import { extension, path, unreachable } from "../0_deps.js";
 import { InputError } from "../0_errors.js";
 import { drop, getLogger, getRandomId, iterateReadableStream, kilobyte, megabyte, minute, mod, PartStream } from "../1_utilities.js";
 import { as, types } from "../2_tl.js";
@@ -83,6 +83,51 @@ export class FileManager {
             return new types.InputFileBig({ id: fileId, parts: result.parts, name });
         }
     }
+    async *downloadInner(location, dcId, params) {
+        const id = "id" in location ? location.id : "photo_id" in location ? location.photo_id : null;
+        if (id != null && __classPrivateFieldGet(this, _FileManager_c, "f").storage.supportsFiles) {
+            const file = await __classPrivateFieldGet(this, _FileManager_c, "f").storage.getFile(id);
+            const partOffset = file == null ? 0 : params?.offset ? Math.ceil(10 / file[1]) - 1 : 0;
+            if (file != null && file[0] > 0) {
+                yield* __classPrivateFieldGet(this, _FileManager_c, "f").storage.iterFileParts(id, file[0], partOffset);
+                return;
+            }
+        }
+        const chunkSize = params?.chunkSize ?? __classPrivateFieldGet(_a, _a, "f", _FileManager_DOWNLOAD_MAX_CHUNK_SIZE);
+        _a.validateChunkSize(chunkSize, __classPrivateFieldGet(_a, _a, "f", _FileManager_DOWNLOAD_MAX_CHUNK_SIZE));
+        const connection = __classPrivateFieldGet(this, _FileManager_c, "f").getCdnConnection(dcId);
+        await connection.connect();
+        const limit = chunkSize;
+        let offset = params?.offset ? BigInt(params.offset) : 0n;
+        let part = 0;
+        try {
+            while (true) {
+                const file = await connection.api.upload.getFile({ location, offset, limit });
+                if (file instanceof types.upload.File) {
+                    yield file.bytes;
+                    if (id != null) {
+                        await __classPrivateFieldGet(this, _FileManager_c, "f").storage.saveFilePart(id, part, file.bytes);
+                    }
+                    ++part;
+                    if (file.bytes.length < limit) {
+                        if (id != null) {
+                            await __classPrivateFieldGet(this, _FileManager_c, "f").storage.setFilePartCount(id, part + 1, chunkSize);
+                        }
+                        break;
+                    }
+                    else {
+                        offset += BigInt(file.bytes.length);
+                    }
+                }
+                else {
+                    unreachable();
+                }
+            }
+        }
+        finally {
+            drop(connection.disconnect());
+        }
+    }
     static validateChunkSize(chunkSize, max) {
         if (chunkSize <= 0) {
             throw new InputError("chunkSize must be bigger than zero.");
@@ -108,7 +153,7 @@ export class FileManager {
                     const big = fileId_.location.source.type == PhotoSourceType.ChatPhotoBig;
                     const peer = await __classPrivateFieldGet(this, _FileManager_c, "f").getInputPeer(Number(fileId_.location.source.chatId)); // TODO: use access hash from source?
                     const location = new types.InputPeerPhotoFileLocation({ big: big ? true : undefined, peer, photo_id: fileId_.location.id });
-                    yield* __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_downloadInner).call(this, location, fileId_.dcId, params);
+                    yield* this.downloadInner(location, fileId_.dcId, params);
                     break;
                 }
                 case FileType.Photo: {
@@ -118,7 +163,7 @@ export class FileManager {
                         file_reference: fileId_.fileReference ?? new Uint8Array(),
                         thumb_size: "thumbnailType" in fileId_.location.source ? String.fromCharCode(fileId_.location.source.thumbnailType) : "",
                     });
-                    yield* __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_downloadInner).call(this, location, fileId_.dcId, params);
+                    yield* this.downloadInner(location, fileId_.dcId, params);
                     break;
                 }
                 case FileType.Thumbnail: {
@@ -128,7 +173,7 @@ export class FileManager {
                         file_reference: fileId_.fileReference ?? new Uint8Array(),
                         thumb_size: "thumbnailType" in fileId_.location.source ? String.fromCharCode(fileId_.location.source.thumbnailType) : unreachable(),
                     });
-                    yield* __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_downloadInner).call(this, location, fileId_.dcId, params);
+                    yield* this.downloadInner(location, fileId_.dcId, params);
                     break;
                 }
             }
@@ -140,7 +185,7 @@ export class FileManager {
                 file_reference: fileId_.fileReference ?? new Uint8Array(),
                 thumb_size: "",
             });
-            yield* __classPrivateFieldGet(this, _FileManager_instances, "m", _FileManager_downloadInner).call(this, location, fileId_.dcId, params);
+            yield* this.downloadInner(location, fileId_.dcId, params);
         }
         else {
             unreachable();
@@ -245,14 +290,16 @@ _a = FileManager, _FileManager_c = new WeakMap(), _FileManager_Lupload = new Wea
     const isBig = buffer.byteLength > __classPrivateFieldGet(_a, _a, "f", _FileManager_BIG_FILE_THRESHOLD);
     const partCount = Math.ceil(buffer.byteLength / chunkSize);
     let promises = new Array();
-    for (let part = 0; part < partCount;) {
+    main: for (let part = 0; part < partCount;) {
         for (let i = 0; i < pool.size; ++i) {
             const api = pool.api();
             for (let i = 0; i < __classPrivateFieldGet(_a, _a, "f", _FileManager_UPLOAD_REQUEST_PER_CONNECTION); ++i) {
                 const start = part * chunkSize;
                 const end = start + chunkSize;
                 const bytes = buffer.subarray(start, end);
-                assert(bytes.length != 0);
+                if (!bytes.length) {
+                    break main;
+                }
                 const thisPart = part++; // `thisPart` must be used instead of `part` in the promise body
                 promises.push(Promise.resolve().then(async () => {
                     while (true) {
@@ -372,50 +419,6 @@ _a = FileManager, _FileManager_c = new WeakMap(), _FileManager_Lupload = new Wea
         }
     }
     return { size: params?.fileSize ? params.fileSize : size, name, contents };
-}, _FileManager_downloadInner = async function* _FileManager_downloadInner(location, dcId, params) {
-    const id = "id" in location ? location.id : "photo_id" in location ? location.photo_id : null;
-    if (id != null && __classPrivateFieldGet(this, _FileManager_c, "f").storage.supportsFiles) {
-        const file = await __classPrivateFieldGet(this, _FileManager_c, "f").storage.getFile(id);
-        const partOffset = file == null ? 0 : params?.offset ? Math.ceil(10 / file[1]) - 1 : 0;
-        if (file != null && file[0] > 0) {
-            yield* __classPrivateFieldGet(this, _FileManager_c, "f").storage.iterFileParts(id, file[0], partOffset);
-            return;
-        }
-    }
-    const chunkSize = params?.chunkSize ?? __classPrivateFieldGet(_a, _a, "f", _FileManager_DOWNLOAD_MAX_CHUNK_SIZE);
-    _a.validateChunkSize(chunkSize, __classPrivateFieldGet(_a, _a, "f", _FileManager_DOWNLOAD_MAX_CHUNK_SIZE));
-    const connection = __classPrivateFieldGet(this, _FileManager_c, "f").getCdnConnection(dcId);
-    await connection.connect();
-    const limit = chunkSize;
-    let offset = params?.offset ? BigInt(params.offset) : 0n;
-    let part = 0;
-    try {
-        while (true) {
-            const file = await connection.api.upload.getFile({ location, offset, limit });
-            if (file instanceof types.upload.File) {
-                yield file.bytes;
-                if (id != null) {
-                    await __classPrivateFieldGet(this, _FileManager_c, "f").storage.saveFilePart(id, part, file.bytes);
-                }
-                ++part;
-                if (file.bytes.length < limit) {
-                    if (id != null) {
-                        await __classPrivateFieldGet(this, _FileManager_c, "f").storage.setFilePartCount(id, part + 1, chunkSize);
-                    }
-                    break;
-                }
-                else {
-                    offset += BigInt(file.bytes.length);
-                }
-            }
-            else {
-                unreachable();
-            }
-        }
-    }
-    finally {
-        drop(connection.disconnect());
-    }
 };
 _FileManager_UPLOAD_MAX_CHUNK_SIZE = { value: 512 * kilobyte };
 _FileManager_DOWNLOAD_MAX_CHUNK_SIZE = { value: 1 * megabyte };

package/esm/client/{1_network_statistics_manager.d.ts → 2_network_statistics_manager.d.ts}

@@ -17,7 +17,7 @@
  * You should have received a copy of the GNU Lesser General Public License
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
-import { C } from "./0_types.js";
+import { C } from "./1_types.js";
 export declare class NetworkStatisticsManager {
     #private;
     constructor(c: C);

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

@@ -19,7 +19,7 @@
  */
 import { enums, types } from "../2_tl.js";
 import { Update } from "../3_types.js";
-import { C } from "./0_types.js";
+import { C } from "./1_types.js";
 type ReactionManagerUpdate = types.UpdateBotMessageReactions | types.UpdateBotMessageReaction | types.UpdateMessageReactions | types.UpdateChannelMessageViews | types.UpdateChannelMessageForwards;
 export declare class ReactionManager {
     #private;

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

@@ -19,7 +19,7 @@
  */
 import { Queue } from "../1_utilities.js";
 import { enums, ReadObject, TLObject, types } from "../2_tl.js";
-import { C } from "./0_types.js";
+import { C } from "./1_types.js";
 type UpdateHandler = (update: enums.Update) => Promise<(() => Promise<unknown>)>;
 export type PtsUpdate = types.UpdateNewMessage | types.UpdateDeleteMessages | types.UpdateReadHistoryInbox | types.UpdateReadHistoryOutbox | types.UpdatePinnedChannelMessages | types.UpdatePinnedMessages | types.UpdateFolderPeers | types.UpdateChannelWebPage | types.UpdateEditMessage | types.UpdateReadMessagesContents | types.UpdateWebPage;
 export type ChannelPtsUpdate = types.UpdateNewChannelMessage | types.UpdateEditChannelMessage | types.UpdateDeleteChannelMessages | types.UpdateChannelTooLong;

package/esm/client/{2_message_manager.d.ts → 3_message_manager.d.ts}

@@ -21,8 +21,8 @@ import { enums, types } from "../2_tl.js";
 import { InputMedia } from "../3_types.js";
 import { ChatAction, ChatMember, FileSource, FileType, ID, Message, MessageEntity, ParseMode, Reaction, Update, UsernameResolver } from "../3_types.js";
 import { AddReactionParams, BanChatMemberParams, CreateInviteLinkParams, DeleteMessagesParams, EditMessageLiveLocationParams, EditMessageMediaParams, EditMessageParams, EditMessageReplyMarkupParams, ForwardMessagesParams, GetCreatedInviteLinksParams, GetHistoryParams, PinMessageParams, SearchMessagesParams, SendAnimationParams, SendAudioParams, SendChatActionParams, SendContactParams, SendDiceParams, SendDocumentParams, SendLocationParams, SendMessageParams, SendPhotoParams, SendPollParams, SendStickerParams, SendVenueParams, SendVideoNoteParams, SendVideoParams, SendVoiceParams, SetChatMemberRightsParams, SetChatPhotoParams, SetReactionsParams, StopPollParams } from "./0_params.js";
-import { C as C_ } from "./0_types.js";
-import { FileManager } from "./1_file_manager.js";
+import { C as C_ } from "./1_types.js";
+import { FileManager } from "./2_file_manager.js";
 interface C extends C_ {
     fileManager: FileManager;
 }

package/esm/client/3_video_chat_manager.d.ts

@@ -0,0 +1,43 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+import { enums, types } from "../2_tl.js";
+import { ID, Update, VideoChatActive, VideoChatScheduled } from "../3_types.js";
+import { DownloadLiveStreamChunkParams, JoinVideoChatParams, StartVideoChatParams } from "./0_params.js";
+import { C as C_ } from "./1_types.js";
+import { FileManager } from "./2_file_manager.js";
+interface C extends C_ {
+    fileManager: FileManager;
+}
+type VideoChatManagerUpdate = types.UpdateGroupCall;
+export declare class VideoChatManager {
+    #private;
+    constructor(c: C);
+    startVideoChat(chatId: ID, params?: StartVideoChatParams): Promise<VideoChatActive>;
+    scheduleVideoChat(chatId: ID, startAt: Date, params?: StartVideoChatParams): Promise<VideoChatScheduled>;
+    joinVideoChat(id: string, params: string, params_?: JoinVideoChatParams): Promise<string>;
+    leaveVideoChat(id: string): Promise<void>;
+    joinLiveStream(id: string): Promise<void>;
+    getVideoChat(id: string): Promise<import("../3_types.js").VideoChat>;
+    static canHandleUpdate(update: enums.Update): update is VideoChatManagerUpdate;
+    handleUpdate(update: VideoChatManagerUpdate): Promise<Update>;
+    getLiveStreamChannels(id: string): Promise<import("../3_types.js").LiveStreamChannel[]>;
+    downloadLiveStreamChunk(id: string, channel: number, scale: number, timestamp: number, params?: DownloadLiveStreamChunkParams): AsyncGenerator<Uint8Array, void, unknown>;
+}
+export {};

package/esm/client/3_video_chat_manager.js

@@ -0,0 +1,194 @@
+/**
+ * MTKruto - Cross-runtime JavaScript library for building Telegram clients
+ * Copyright (C) 2023-2024 Roj <https://roj.im/>
+ *
+ * This file is part of MTKruto.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+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 _VideoChatManager_instances, _VideoChatManager_c, _VideoChatManager_createGroupCall, _VideoChatManager_getInputGroupCall, _VideoChatManager_getCall;
+import { unreachable } from "../0_deps.js";
+import { InputError } from "../0_errors.js";
+import { getRandomId, toUnixTimestamp, ZERO_CHANNEL_ID } from "../1_utilities.js";
+import { as, types } from "../2_tl.js";
+import { constructLiveStreamChannel, constructVideoChat } from "../3_types.js";
+export class VideoChatManager {
+    constructor(c) {
+        _VideoChatManager_instances.add(this);
+        _VideoChatManager_c.set(this, void 0);
+        __classPrivateFieldSet(this, _VideoChatManager_c, c, "f");
+    }
+    async startVideoChat(chatId, params) {
+        await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.assertUser("startVideoChat");
+        return await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_createGroupCall).call(this, chatId, params?.title, params?.liveStream || undefined);
+    }
+    async scheduleVideoChat(chatId, startAt, params) {
+        await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.assertUser("scheduleVideoChat");
+        return await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_createGroupCall).call(this, chatId, params?.title, params?.liveStream || undefined, startAt);
+    }
+    async joinVideoChat(id, params, params_) {
+        await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.assertUser("joinVideoChat");
+        const call = await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_getInputGroupCall).call(this, id);
+        const { updates } = await __classPrivateFieldGet(this, _VideoChatManager_c, "f").api.phone.joinGroupCall({
+            call,
+            join_as: params_?.joinAs ? await __classPrivateFieldGet(this, _VideoChatManager_c, "f").getInputPeer(params_.joinAs) : new types.InputPeerSelf(),
+            params: new types.DataJSON({ data: params }),
+            invite_hash: params_?.inviteHash,
+            muted: params_?.audio ? undefined : true,
+            video_stopped: params_?.video ? undefined : true,
+        }).then((v) => v[as](types.Updates));
+        const updateGroupCall = updates
+            .find((v) => v instanceof types.UpdateGroupCallConnection);
+        if (!updateGroupCall)
+            unreachable();
+        return updateGroupCall.params.data;
+    }
+    async leaveVideoChat(id) {
+        await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.assertUser("leaveVideoChat");
+        await __classPrivateFieldGet(this, _VideoChatManager_c, "f").api.phone.leaveGroupCall({ call: await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_getInputGroupCall).call(this, id), source: 0 });
+    }
+    async joinLiveStream(id) {
+        await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.assertUser("joinLiveStream");
+        const call = await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_getInputGroupCall).call(this, id);
+        const { updates } = await __classPrivateFieldGet(this, _VideoChatManager_c, "f").api.phone.joinGroupCall({
+            call,
+            join_as: new types.InputPeerSelf(),
+            params: new types.DataJSON({
+                data: JSON.stringify({
+                    fingerprints: [],
+                    pwd: "",
+                    ssrc: getRandomId(true),
+                    "ssrc-groups": [],
+                    ufrag: "",
+                }),
+            }),
+        }).then((v) => v[as](types.Updates));
+        const updateGroupCall = updates
+            .find((v) => v instanceof types.UpdateGroupCallConnection);
+        if (!updateGroupCall)
+            unreachable();
+    }
+    async getVideoChat(id) {
+        await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.assertUser("getVideoChat");
+        return constructVideoChat(await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_getCall).call(this, id));
+    }
+    static canHandleUpdate(update) {
+        return update instanceof types.UpdateGroupCall;
+    }
+    async handleUpdate(update) {
+        let chatId = Number(-update.chat_id);
+        const fullChat = await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.getFullChat(chatId).then((v) => v == null ? __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.getFullChat(chatId = ZERO_CHANNEL_ID - Number(update.chat_id)) : v);
+        let updateFullChat = false;
+        if (update.call instanceof types.GroupCallDiscarded) {
+            await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.setGroupCall(update.call.id, null);
+            await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.setGroupCallAccessHash(update.call.id, null);
+            if (fullChat != null) {
+                fullChat.call = undefined;
+                updateFullChat = true;
+            }
+        }
+        else {
+            await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.setGroupCall(update.call.id, update.call);
+            await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.setGroupCallAccessHash(update.call.id, update.call.access_hash);
+            if (fullChat != null) {
+                if (!("call" in fullChat) || !fullChat.call || fullChat.call.id != update.call.id) {
+                    fullChat.call = new types.InputGroupCall(update.call);
+                    updateFullChat = true;
+                }
+            }
+        }
+        if (updateFullChat) {
+            await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.setFullChat(chatId, fullChat);
+        }
+        return { videoChat: constructVideoChat(update.call) };
+    }
+    async getLiveStreamChannels(id) {
+        await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.assertUser("getLiveStreamChannels");
+        const call = await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_getCall).call(this, id);
+        if (!(call instanceof types.GroupCall) || !call.rtmp_stream) {
+            throw new InputError("Not a live stream.");
+        }
+        const client = __classPrivateFieldGet(this, _VideoChatManager_c, "f").getCdnConnection(call.stream_dc_id);
+        await client.connect();
+        try {
+            const streams = await client.api.phone.getGroupCallStreamChannels({ call: await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_getInputGroupCall).call(this, id) });
+            return streams.channels.map(constructLiveStreamChannel);
+        }
+        finally {
+            await client.disconnect();
+        }
+    }
+    async *downloadLiveStreamChunk(id, channel, scale, timestamp, params) {
+        await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.assertUser("downloadLiveStreamChunk");
+        const call = await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_getCall).call(this, id);
+        if (!(call instanceof types.GroupCall) || !call.rtmp_stream) {
+            throw new InputError("Not a live stream.");
+        }
+        const quality = params?.quality ?? "low";
+        const location = new types.InputGroupCallStream({
+            call: new types.InputGroupCall(call),
+            scale,
+            time_ms: BigInt(timestamp),
+            video_channel: channel,
+            video_quality: quality == "low" ? 0 : quality == "medium" ? 1 : quality == "high" ? 2 : (() => {
+                throw new InputError("Got invalid quality.");
+            })(),
+        });
+        yield* __classPrivateFieldGet(this, _VideoChatManager_c, "f").fileManager.downloadInner(location, call.stream_dc_id ?? unreachable());
+    }
+}
+_VideoChatManager_c = new WeakMap(), _VideoChatManager_instances = new WeakSet(), _VideoChatManager_createGroupCall = async function _VideoChatManager_createGroupCall(chatId, title, liveStream, scheduleDate) {
+    const peer = await __classPrivateFieldGet(this, _VideoChatManager_c, "f").getInputPeer(chatId);
+    if (peer instanceof types.InputPeerUser) {
+        throw new InputError("Video chats are only available for groups and channels.");
+    }
+    const { updates } = await __classPrivateFieldGet(this, _VideoChatManager_c, "f").api.phone.createGroupCall({
+        peer,
+        random_id: getRandomId(true),
+        title,
+        rtmp_stream: liveStream,
+        schedule_date: scheduleDate ? toUnixTimestamp(scheduleDate) : undefined,
+    }).then((v) => v[as](types.Updates));
+    const updateGroupCall = updates
+        .find((v) => v instanceof types.UpdateGroupCall);
+    if (!updateGroupCall) {
+        unreachable();
+    }
+    return constructVideoChat(updateGroupCall.call);
+}, _VideoChatManager_getInputGroupCall = async function _VideoChatManager_getInputGroupCall(id_) {
+    const id = BigInt(id_);
+    const accessHash = await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.getGroupCallAccessHash(id);
+    if (accessHash == null) {
+        throw new InputError("Video chat not found.");
+    }
+    return new types.InputGroupCall({ id, access_hash: accessHash });
+}, _VideoChatManager_getCall = async function _VideoChatManager_getCall(id) {
+    let groupCall = await __classPrivateFieldGet(this, _VideoChatManager_c, "f").storage.getGroupCall(BigInt(id));
+    if (groupCall == null) {
+        const call = await __classPrivateFieldGet(this, _VideoChatManager_instances, "m", _VideoChatManager_getInputGroupCall).call(this, id);
+        groupCall = await __classPrivateFieldGet(this, _VideoChatManager_c, "f").api.phone.getGroupCall({ call, limit: 1 }).then((v) => v.call);
+    }
+    return groupCall;
+};

package/{script/client/3_callback_query_manager.d.ts → esm/client/4_callback_query_manager.d.ts}

@@ -20,8 +20,8 @@
 import { enums, types } from "../2_tl.js";
 import { CallbackQueryQuestion, ID, Update } from "../3_types.js";
 import { AnswerCallbackQueryParams } from "./0_params.js";
-import { C as C_ } from "./0_types.js";
-import { MessageManager } from "./2_message_manager.js";
+import { C as C_ } from "./1_types.js";
+import { MessageManager } from "./3_message_manager.js";
 type C = C_ & {
     messageManager: MessageManager;
 };

package/esm/client/{3_callback_query_manager.js → 4_callback_query_manager.js}

@@ -50,6 +50,7 @@ export class CallbackQueryManager {
         });
     }
     async sendCallbackQuery(chatId, messageId, question) {
+        await __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").storage.assertUser("sendCallbackQuery");
         checkMessageId(messageId);
         validateCallbackQueryQuestion(question);
         const peer = await __classPrivateFieldGet(this, _CallbackQueryManager_c, "f").getInputPeer(chatId), peerId = peerToChatId(peer), questionKey = JSON.stringify(question);

package/{script/client/3_chat_list_manager.d.ts → esm/client/4_chat_list_manager.d.ts}

@@ -18,10 +18,10 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 import { enums, types } from "../2_tl.js";
-import { Chat, ID } from "../3_types.js";
-import { C as C_ } from "./0_types.js";
-import { FileManager } from "./1_file_manager.js";
-import { MessageManager } from "./2_message_manager.js";
+import { ChatListItem, ID } from "../3_types.js";
+import { C as C_ } from "./1_types.js";
+import { FileManager } from "./2_file_manager.js";
+import { MessageManager } from "./3_message_manager.js";
 type C = C_ & {
     fileManager: FileManager;
     messageManager: MessageManager;
@@ -31,9 +31,9 @@ export declare class ChatListManager {
     #private;
     constructor(c: C);
     reassignChatLastMessage(chatId: number, add?: boolean, sendUpdate?: boolean): Promise<() => Promise<void>>;
-    getChats(from?: "archived" | "main", after?: Chat, limit?: number): Promise<Chat[]>;
+    getChats(from?: "archived" | "main", after?: ChatListItem, limit?: number): Promise<ChatListItem[]>;
     static canHandleUpdate(update: enums.Update): update is ChatListManagerUpdate;
     handleUpdate(update: ChatListManagerUpdate): Promise<void>;
-    getChat(chatId: ID): Promise<Chat>;
+    getChat(chatId: ID): Promise<import("../3_types.js").Chat>;
 }
 export {};