Return custom message object from friendly methods.

gramjs/client/TelegramClient.ts

@@ -230,7 +230,10 @@ export class TelegramClient extends TelegramBaseClient {
         return messageMethods.sendMessage(this, entity, params);
     }
 
-    forwardMessages(entity: EntityLike, params: messageMethods.ForwardMessagesParams) {
+    forwardMessages(
+        entity: EntityLike,
+        params: messageMethods.ForwardMessagesParams
+    ) {
         return messageMethods.forwardMessages(this, entity, params);
     }
 
@@ -463,7 +466,7 @@ export class TelegramClient extends TelegramBaseClient {
                 return sender;
             } catch (e) {
                 // we can't create sender for our own main DC
-                if (e.message=="DC_ID_INVALID"){
+                if (e.message == "DC_ID_INVALID") {
                     return this._sender;
                 }
                 await sender.disconnect();
@@ -534,7 +537,7 @@ export class TelegramClient extends TelegramBaseClient {
     }
 
     async _borrowExportedSender(dcId: number, retries = this._requestRetries) {
-        this._log.debug(`Borrowing client for DC ${dcId}`)
+        this._log.debug(`Borrowing client for DC ${dcId}`);
         let senderPromise = this._borrowedSenderPromises[dcId];
         if (!senderPromise) {
             senderPromise = this._createExportedSender(dcId, retries);
@@ -549,5 +552,9 @@ export class TelegramClient extends TelegramBaseClient {
         return senderPromise;
     }
 
+    _getResponseMessage(req: any, result: any, inputChat: any) {
+        return parseMethods._getResponseMessage(this, req, result, inputChat);
+    }
+
     // endregion
 }

gramjs/client/messageParse.ts

@@ -1,7 +1,11 @@
-import { sanitizeParseMode } from "../Utils";
+import { getPeerId, sanitizeParseMode } from "../Utils";
 import { Api } from "../tl";
 import type { EntityLike, ValueOf } from "../define";
 import type { TelegramClient } from "./TelegramClient";
+import { utils } from "../index";
+import { _EntityType, _entityType, isArrayLike } from "../Helpers";
+import { Message } from "../tl/custom/message";
+import bigInt from "big-integer";
 
 export type messageEntities =
     | typeof Api.MessageEntityBold
@@ -63,113 +67,155 @@ export function _parseMessageText(
     return parseMode.parse(message);
 }
 
-/* TODO make your own smh
-export function _getResponseMessage(request: Api.AnyRequest, result: Api.TypeUpdates, inputChat: Api.TypeInputPeer) {
+export function _getResponseMessage(
+    client: TelegramClient,
+    request: any,
+    result: any,
+    inputChat: any
+) {
+    console.log("requestsd first is", request);
+    console.log("resulted first is", result);
     let updates = [];
+
     let entities = new Map();
     if (result instanceof Api.UpdateShort) {
-        updates = [result.update]
-    } else if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+        updates = [result.update];
+    } else if (
+        result instanceof Api.Updates ||
+        result instanceof Api.UpdatesCombined
+    ) {
         updates = result.updates;
         for (const x of [...result.users, ...result.chats]) {
-            entities.set(getPeerId(x), x);
+            entities.set(utils.getPeerId(x), x);
         }
     } else {
         return;
     }
-    const randomToId = new Map();
-    const idToMessage = new Map();
-    const schedToMessage = new Map();
+    const randomToId = new Map<string, number>();
+    const idToMessage = new Map<number, Message>();
+    const schedToMessage = new Map<number, Message>();
     for (const update of updates) {
         if (update instanceof Api.UpdateMessageID) {
-            randomToId.set(update.randomId, update.id);
-        } else if (update instanceof Api.UpdateNewChannelMessage || update instanceof Api.UpdateNewMessage) {
-            // @ts-ignore
-            // TODO update.message._finishInit(this, entities, inputChat);
-            if ('randomId' in request || isArrayLike(request)) {
-                idToMessage.set(update.message.id, update.message);
+            randomToId.set(update.randomId.toString(), update.id);
+        } else if (
+            update instanceof Api.UpdateNewChannelMessage ||
+            update instanceof Api.UpdateNewMessage
+        ) {
+            (update.message as unknown as Message)._finishInit(
+                client,
+                entities,
+                inputChat
+            );
+            if ("randomId" in request || isArrayLike(request)) {
+                idToMessage.set(
+                    update.message.id,
+                    update.message as unknown as Message
+                );
             } else {
+                return update.message as unknown as Message;
+            }
+        } else if (
+            update instanceof Api.UpdateEditMessage &&
+            "peer" in request &&
+            _entityType(request.peer) != _EntityType.CHANNEL
+        ) {
+            (update.message as unknown as Message)._finishInit(
+                client,
+                entities,
+                inputChat
+            );
+            if ("randomId" in request) {
+                idToMessage.set(
+                    update.message.id,
+                    update.message as unknown as Message
+                );
+            } else if ("id" in request && request.id === update.message.id) {
                 return update.message;
             }
-        } else if (update instanceof Api.UpdateEditMessage && 'peer' in request && _entityType(request.peer) != _EntityType.CHANNEL) {
-            // @ts-ignore
-            // TODO update.message._finishInit(this, entities, inputChat);
-            if ('randomId' in request) {
-                idToMessage.set(update.message.id, update.message);
-            } else if ('id' in request && request.id === update.message.id) {
+        } else if (
+            update instanceof Api.UpdateEditChannelMessage &&
+            "peer" in request &&
+            getPeerId(request.peer) ==
+                getPeerId((update.message as unknown as Message).peerId)
+        ) {
+            if (request.id == update.message.id) {
+                (update.message as unknown as Message)._finishInit(
+                    client,
+                    entities,
+                    inputChat
+                );
                 return update.message;
             }
-        } else if (update instanceof Api.UpdateEditChannelMessage &&
-            update.message instanceof Api.Message && 'peer' in request && getPeerId(request.peer) == getPeerId(update.message.peerId)) {
-            schedToMessage.set(update.message.id, update.message);
+        } else if (update instanceof Api.UpdateNewScheduledMessage) {
+            (update.message as unknown as Message)._finishInit(
+                client,
+                entities,
+                inputChat
+            );
+            schedToMessage.set(
+                update.message.id,
+                update.message as unknown as Message
+            );
         } else if (update instanceof Api.UpdateMessagePoll) {
-            if ('media' in request && request.media && "poll" in request.media && request?.media.poll.id == update.pollId) {
-                if ('peer' in request) {
-                    const peerId = getPeer(request.peer) as Api.TypePeer;
-                    const poll = update.poll;
-                    if (poll && 'id' in request) {
-                        const m = new Api.Message({
-                            id: request.id,
-                            peerId: peerId,
-                            media: new Api.MessageMediaPoll({
-                                poll: poll,
-                                results: update.results
-                            }),
-                            message: '',
-                            date: 0,
-                        });
-                        // @ts-ignore
-                        m._finishInit(this, entities, inputChat);
-                        return m;
-                    }
-                }
+            if (request.media.poll.id == update.pollId) {
+                const m = new Message({
+                    id: request.id,
+                    peerId: utils.getPeerId(request.peer),
+                    media: new Api.MessageMediaPoll({
+                        poll: update.poll!,
+                        results: update.results,
+                    }),
+                    message: "",
+                    date: 0,
+                });
+                m._finishInit(client, entities, inputChat);
+                return m;
             }
         }
-
     }
-    if (!request) {
+    if (request == undefined) {
         return idToMessage;
     }
-    let mapping;
-    let opposite = new Map();
-
-    if (!("scheduleDate" in request)) {
-        mapping = idToMessage;
-    } else {
-        mapping = schedToMessage;
-        opposite = idToMessage;
+    console.log("request is", request);
+    console.log("random id is", request.randomId);
+    if (!(result instanceof Api.UpdateShort)) {
+        console.log("result is", result.updates);
     }
-    let randomId: any = (typeof request == 'number' || isArrayLike(request)) ? request : 'randomId' in request ? request.randomId : undefined;
-
-    if (randomId === undefined) {
-        // TODO add logging
-        return null;
+    let randomId =
+        isArrayLike(request) ||
+        typeof request == "number" ||
+        bigInt.isInstance(request)
+            ? request
+            : request.randomId.toString();
+    if (!randomId) {
+        client._log.warn(
+            `No randomId in ${request} to map to. returning undefined for ${result}`
+        );
+        return undefined;
     }
-    if (!isArrayLike(request)) {
-        let msg = mapping.get(randomToId.get(randomId));
-        if (!msg) {
-            msg = opposite.get(randomToId.get(randomId));
-        }
+
+    if (!isArrayLike(randomId)) {
+        const msg = idToMessage.get(randomToId.get(randomId)!);
         if (!msg) {
-            throw new Error(`Request ${request.className} had missing message mapping`)
-            // TODO add logging
+            client._log.warn(
+                `Request ${request} had missing message mapping ${result}`
+            );
         }
         return msg;
-    }
-    if (isArrayLike((randomId))) {
-
-        const maps = [];
-        // @ts-ignore
-        for (const rnd of randomId) {
-            const d = mapping.get(randomToId.get(rnd));
-            const o = opposite.get(randomToId.get(rnd));
-
-            maps.push(d ?? o)
-
+    } else {
+        const mapping = [];
+        for (let i = 0; i < randomId.length; i++) {
+            const rnd = randomId[i] + "";
+            const msg = idToMessage.get(randomToId.get(rnd)!);
+            if (!msg) {
+                client._log.warn(
+                    `Request ${request} had missing message mapping ${result}`
+                );
+                break;
+            } else {
+                mapping.push(msg);
+            }
         }
-        return maps;
+        return mapping;
     }
 }
-
-
-*/

gramjs/client/messages.ts

@@ -1,20 +1,24 @@
 import { Api } from "../tl";
-import type { Message } from "../tl/custom/message";
+import { Message } from "../tl/custom/message";
 import type {
     DateLike,
     EntityLike,
     FileLike,
     MarkupLike,
     MessageIDLike,
-    MessageLike
+    MessageLike,
 } from "../define";
 import { RequestIter } from "../requestIter";
-import { _EntityType, _entityType, TotalList, isArrayLike, groupBy } from "../Helpers";
+import {
+    _EntityType,
+    _entityType,
+    TotalList,
+    isArrayLike,
+    groupBy,
+} from "../Helpers";
 import { getMessageId, getPeerId } from "../Utils";
 import type { TelegramClient } from "../";
 import { utils } from "../";
-import { cli } from "webpack";
-
 
 const _MAX_CHUNK_SIZE = 100;
 
@@ -45,17 +49,17 @@ export class _MessagesIter extends RequestIter {
     lastId?: number;
 
     async _init({
-                    entity,
-                    offsetId,
-                    minId,
-                    maxId,
-                    fromUser,
-                    offsetDate,
-                    addOffset,
-                    filter,
-                    search,
-                    replyTo
-                }: MessageIterParams) {
+        entity,
+        offsetId,
+        minId,
+        maxId,
+        fromUser,
+        offsetDate,
+        addOffset,
+        filter,
+        search,
+        replyTo,
+    }: MessageIterParams) {
         if (entity) {
             this.entity = await this.client.getInputEntity(entity);
         } else {
@@ -112,7 +116,7 @@ export class _MessagesIter extends RequestIter {
                 offsetRate: undefined,
                 offsetPeer: new Api.InputPeerEmpty(),
                 offsetId: offsetId,
-                limit: 1
+                limit: 1,
             });
         } else if (replyTo !== undefined) {
             this.request = new Api.messages.GetReplies({
@@ -124,7 +128,7 @@ export class _MessagesIter extends RequestIter {
                 limit: 0,
                 maxId: 0,
                 minId: 0,
-                hash: 0
+                hash: 0,
             });
         } else if (
             search !== undefined ||
@@ -149,7 +153,7 @@ export class _MessagesIter extends RequestIter {
                 maxId: 0,
                 minId: 0,
                 hash: 0,
-                fromId: fromUser
+                fromId: fromUser,
             });
             if (
                 filter instanceof Api.InputMessagesFilterEmpty &&
@@ -159,7 +163,7 @@ export class _MessagesIter extends RequestIter {
             ) {
                 for await (const m of this.client.iterMessages(this.entity, {
                     limit: 1,
-                    offsetDate: offsetDate
+                    offsetDate: offsetDate,
                 })) {
                     this.request.offsetId = m.id + 1;
                 }
@@ -173,7 +177,7 @@ export class _MessagesIter extends RequestIter {
                 minId: 0,
                 maxId: 0,
                 addOffset: addOffset,
-                hash: 0
+                hash: 0,
             });
         }
         if (this.limit <= 0) {
@@ -243,8 +247,7 @@ export class _MessagesIter extends RequestIter {
             try {
                 // if this fails it shouldn't be a big problem
                 message._finishInit(this.client, entities, this.entity);
-            } catch (e) {
-            }
+            } catch (e) {}
             message._entities = entities;
             this.buffer?.push(message);
         }
@@ -350,13 +353,13 @@ export class _IDsIter extends RequestIter {
                 r = await this.client.invoke(
                     new Api.channels.GetMessages({
                         channel: this._entity,
-                        id: ids
+                        id: ids,
                     })
                 );
             } catch (e) {
                 if (e.message == "MESSAGE_IDS_EMPTY") {
                     r = new Api.messages.MessagesNotModified({
-                        count: ids.length
+                        count: ids.length,
                     });
                 } else {
                     throw e;
@@ -365,7 +368,7 @@ export class _IDsIter extends RequestIter {
         } else {
             r = await this.client.invoke(
                 new Api.messages.GetMessages({
-                    id: ids
+                    id: ids,
                 })
             );
             if (this._entity) {
@@ -471,7 +474,7 @@ export function iterMessages(
         waitTime,
         ids,
         reverse = false,
-        replyTo
+        replyTo,
     }: IterMessagesParams
 ) {
     if (ids) {
@@ -483,11 +486,11 @@ export function iterMessages(
             ids.length,
             {
                 reverse: reverse,
-                waitTime: waitTime
+                waitTime: waitTime,
             },
             {
                 entity: entity,
-                ids: ids
+                ids: ids,
             }
         );
     }
@@ -496,7 +499,7 @@ export function iterMessages(
         limit || 1,
         {
             waitTime: waitTime,
-            reverse: reverse
+            reverse: reverse,
         },
         {
             entity: entity,
@@ -508,7 +511,7 @@ export function iterMessages(
             addOffset: addOffset,
             filter: filter,
             search: search,
-            replyTo: replyTo
+            replyTo: replyTo,
         }
     );
 }
@@ -553,7 +556,7 @@ export async function sendMessage(
         clearDraft,
         buttons,
         silent,
-        schedule
+        schedule,
     }: SendMessageParams
 ) {
     if (file) {
@@ -597,7 +600,7 @@ export async function sendMessage(
             entities: message.entities,
             clearDraft: clearDraft,
             noWebpage: !(message.media instanceof Api.MessageMediaWebPage),
-            scheduleDate: schedule
+            scheduleDate: schedule,
         });
         message = message.message;
     } else {
@@ -621,22 +624,33 @@ export async function sendMessage(
             clearDraft: clearDraft,
             silent: silent,
             replyMarkup: client.buildReplyMarkup(buttons),
-            scheduleDate: schedule
+            scheduleDate: schedule,
         });
     }
     const result = await client.invoke(request);
-    return result;
-    //return client._getResponseMessage(request, result, entity);
+    if (result instanceof Api.UpdateShortSentMessage) {
+        const msg = new Message({
+            id: result.id,
+            peerId: await client._getPeer(entity),
+            message: message,
+            date: result.date,
+            out: result.out,
+            media: result.media,
+            entities: result.entities,
+            replyMarkup: request.replyMarkup,
+            ttlPeriod: result.ttlPeriod,
+        });
+        msg._finishInit(client, new Map(), entity);
+        return msg;
+    }
+    return client._getResponseMessage(request, result, entity) as Message;
 }
 
-export async function forwardMessages(client: TelegramClient,
-                                      entity: EntityLike,
-                                      {
-                                          messages,
-                                          fromPeer,
-                                          silent,
-                                          schedule
-                                      }: ForwardMessagesParams) {
+export async function forwardMessages(
+    client: TelegramClient,
+    entity: EntityLike,
+    { messages, fromPeer, silent, schedule }: ForwardMessagesParams
+) {
     entity = await client.getInputEntity(entity);
     let fromPeerId: number | undefined;
     if (fromPeer) {
@@ -655,8 +669,11 @@ export async function forwardMessages(client: TelegramClient,
             throw new Error(`Cannot forward ${m}`);
         }
     };
-    const sent = [];
-    for (let [chatId, chunk] of groupBy(messages, getKey) as Map<number, Message[] | number[]>) {
+    const sent: Message[] = [];
+    for (let [chatId, chunk] of groupBy(messages, getKey) as Map<
+        number,
+        Message[] | number[]
+    >) {
         let chat;
         let numbers: number[] = [];
         if (typeof chunk[0] == "number") {
@@ -672,16 +689,16 @@ export async function forwardMessages(client: TelegramClient,
             id: numbers,
             toPeer: entity,
             silent: silent,
-            scheduleDate: schedule
+            scheduleDate: schedule,
         });
         const result = await client.invoke(request);
-        //sent.push(client._getResponseMessage(req, result, entity))
-        sent.push(result);
+        sent.push(
+            client._getResponseMessage(request, result, entity) as Message
+        );
     }
     return sent;
 }
 
-
 /**
  * Used to edit a message by changing it's text or media
  * message refers to the message to be edited not what to edit
@@ -699,7 +716,7 @@ export async function editMessage(
         file,
         forceDocument,
         buttons,
-        schedule
+        schedule,
     }: EditMessageParams
 ) {
     entity = await client.getInputEntity(entity);
@@ -709,20 +726,18 @@ export async function editMessage(
             parseMode
         );
     }
-    const msg = await client.invoke(
-        new Api.messages.EditMessage({
-            peer: entity,
-            id: utils.getMessageId(message),
-            message: text,
-            noWebpage: !linkPreview,
-            entities: formattingEntities,
-            //media: no media for now,
-            replyMarkup: client.buildReplyMarkup(buttons),
-            scheduleDate: schedule
-        })
-    );
-    return msg;
-    //return client._getResponseMessage(request, result, entity);
+    const request = new Api.messages.EditMessage({
+        peer: entity,
+        id: utils.getMessageId(message),
+        message: text,
+        noWebpage: !linkPreview,
+        entities: formattingEntities,
+        //media: no media for now,
+        replyMarkup: client.buildReplyMarkup(buttons),
+        scheduleDate: schedule,
+    });
+    const result = await client.invoke(request);
+    return client._getResponseMessage(request, result, entity) as Message;
 }
 
 // TODO do the rest

gramjs/client/uploads.ts

@@ -421,7 +421,8 @@ export async function sendFile(
         clearDraft: clearDraft,
     });
     // todo get message
-    return client.invoke(request);
+    const result = client.invoke(request);
+    return client._getResponseMessage(request, result, entity);
 }
 
 function fileToBuffer(file: File | CustomFile) {

gramjs/events/common.ts

@@ -1,12 +1,10 @@
 import { Api } from "../tl";
 import type { Entity, EntityLike } from "../define";
 import { ChatGetter } from "../tl/custom";
-import type { TelegramClient } from "../client/TelegramClient";
+import type { TelegramClient } from "..";
 
-import bigInt from "big-integer";
 import { isArrayLike } from "../Helpers";
 import { utils } from "../";
-import { Message } from "../tl/patched";
 
 export async function _intoIdSet(
     client: TelegramClient,
@@ -118,7 +116,6 @@ interface EventCommonInterface {
     msgId?: number;
     broadcast?: boolean;
 }
-
 export class EventCommon extends ChatGetter {
     _eventName = "Event";
     _entities: Map<number, Entity>;

gramjs/index.ts

@@ -1,13 +1,13 @@
 export { Api } from "./tl";
+import * as tl from "./tl";
+
 export { TelegramClient } from "./client/TelegramClient";
 export { Connection } from "./network";
 export { version } from "./Version";
 import * as utils from "./Utils";
-import * as events from './events';
 import * as errors from "./errors";
 import * as sessions from "./sessions";
 import * as extensions from "./extensions";
 import * as helpers from "./Helpers";
-import * as tl from "./tl";
 
-export { utils, errors, sessions, extensions, helpers, events, tl };
+export { utils, errors, sessions, extensions, helpers, tl };

gramjs/tl/api.js

@@ -3,17 +3,17 @@ const bigInt = require("big-integer");
 const {
     generateRandomBytes,
     readBigIntFromBuffer,
-    isArrayLike
+    isArrayLike,
 } = require("../Helpers");
 
 function generateRandomBigInt() {
-    return readBigIntFromBuffer(generateRandomBytes(8), false);
+    return readBigIntFromBuffer(generateRandomBytes(8), false, true);
 }
 
 const {
     parseTl,
     serializeBytes,
-    serializeDate
+    serializeDate,
 } = require("./generationHelpers");
 const { IS_NODE, toSignedLittleBuffer } = require("../Helpers");
 let tlContent, schemeContent;
@@ -38,7 +38,7 @@ const AUTO_CASTS = new Set([
     "InputPhoto",
     "InputMessage",
     "InputDocument",
-    "InputChatPhoto"
+    "InputChatPhoto",
 ]);
 
 class CastError extends Error {
@@ -114,63 +114,63 @@ function extractParams(fileContent) {
 
 function argToBytes(x, type) {
     switch (type) {
-    case "int":
-        const i = Buffer.alloc(4);
-        i.writeInt32LE(x, 0);
-        return i;
-    case "long":
-        return toSignedLittleBuffer(x, 8);
-    case "int128":
-        return toSignedLittleBuffer(x, 16);
-    case "int256":
-        return toSignedLittleBuffer(x, 32);
-    case "double":
-        const d = Buffer.alloc(8);
-        d.writeDoubleLE(x, 0);
-        return d;
-    case "string":
-        return serializeBytes(x);
-    case "Bool":
-        return x
-            ? Buffer.from("b5757299", "hex")
-            : Buffer.from("379779bc", "hex");
-    case "true":
-        return Buffer.alloc(0);
-    case "bytes":
-        return serializeBytes(x);
-    case "date":
-        return serializeDate(x);
-    default:
-        return x.getBytes();
+        case "int":
+            const i = Buffer.alloc(4);
+            i.writeInt32LE(x, 0);
+            return i;
+        case "long":
+            return toSignedLittleBuffer(x, 8);
+        case "int128":
+            return toSignedLittleBuffer(x, 16);
+        case "int256":
+            return toSignedLittleBuffer(x, 32);
+        case "double":
+            const d = Buffer.alloc(8);
+            d.writeDoubleLE(x, 0);
+            return d;
+        case "string":
+            return serializeBytes(x);
+        case "Bool":
+            return x
+                ? Buffer.from("b5757299", "hex")
+                : Buffer.from("379779bc", "hex");
+        case "true":
+            return Buffer.alloc(0);
+        case "bytes":
+            return serializeBytes(x);
+        case "date":
+            return serializeDate(x);
+        default:
+            return x.getBytes();
     }
 }
 
 async function getInputFromResolve(utils, client, peer, peerType) {
     switch (peerType) {
-    case "InputPeer":
-        return utils.getInputPeer(await client.getInputEntity(peer));
-    case "InputChannel":
-        return utils.getInputChannel(await client.getInputEntity(peer));
-    case "InputUser":
-        return utils.getInputUser(await client.getInputEntity(peer));
-    case "InputDialogPeer":
-        return await client._getInputDialog(peer);
-    case "InputNotifyPeer":
-        return await client._getInputNotify(peer);
-    case "InputMedia":
-        return utils.getInputMedia(peer);
-    case "InputPhoto":
-        return utils.getInputPhoto(peer);
-    case "InputMessage":
-        return utils.getInputMessage(peer);
-    case "InputDocument":
-        return utils.getInputDocument(peer);
-    case "InputChatPhoto":
-        return utils.getInputChatPhoto(peer);
-    case "chatId,int":
-        return await client.getPeerId(peer, false);
-    default:
-        throw new Error("unsupported peer type : " + peerType);
+        case "InputPeer":
+            return utils.getInputPeer(await client.getInputEntity(peer));
+        case "InputChannel":
+            return utils.getInputChannel(await client.getInputEntity(peer));
+        case "InputUser":
+            return utils.getInputUser(await client.getInputEntity(peer));
+        case "InputDialogPeer":
+            return await client._getInputDialog(peer);
+        case "InputNotifyPeer":
+            return await client._getInputNotify(peer);
+        case "InputMedia":
+            return utils.getInputMedia(peer);
+        case "InputPhoto":
+            return utils.getInputPhoto(peer);
+        case "InputMessage":
+            return utils.getInputMessage(peer);
+        case "InputDocument":
+            return utils.getInputDocument(peer);
+        case "InputChatPhoto":
+            return utils.getInputChatPhoto(peer);
+        case "chatId,int":
+            return await client.getPeerId(peer, false);
+        default:
+            throw new Error("unsupported peer type : " + peerType);
     }
 }
 
@@ -191,32 +191,32 @@ function getArgFromReader(reader, arg) {
         return reader.readInt();
     } else {
         switch (arg.type) {
-        case "int":
-            return reader.readInt();
-        case "long":
-            return reader.readLong();
-        case "int128":
-            return reader.readLargeInt(128);
-        case "int256":
-            return reader.readLargeInt(256);
-        case "double":
-            return reader.readDouble();
-        case "string":
-            return reader.tgReadString();
-        case "Bool":
-            return reader.tgReadBool();
-        case "true":
-            return true;
-        case "bytes":
-            return reader.tgReadBytes();
-        case "date":
-            return reader.tgReadDate();
-        default:
-            if (!arg.skipConstructorId) {
-                return reader.tgReadObject();
-            } else {
-                return api.constructors[arg.type].fromReader(reader);
-            }
+            case "int":
+                return reader.readInt();
+            case "long":
+                return reader.readLong();
+            case "int128":
+                return reader.readLargeInt(128);
+            case "int256":
+                return reader.readLargeInt(256);
+            case "double":
+                return reader.readDouble();
+            case "string":
+                return reader.tgReadString();
+            case "Bool":
+                return reader.tgReadBool();
+            case "true":
+                return true;
+            case "bytes":
+                return reader.tgReadBytes();
+            case "date":
+                return reader.tgReadDate();
+            default:
+                if (!arg.skipConstructorId) {
+                    return reader.tgReadObject();
+                } else {
+                    return api.constructors[arg.type].fromReader(reader);
+                }
         }
     }
 }
@@ -224,31 +224,31 @@ function getArgFromReader(reader, arg) {
 function compareType(value, type) {
     let correct = true;
     switch (type) {
-    case "number":
-        correct = typeof value === "number" || value === undefined;
-        break;
-    case "string":
-    case "boolean":
-        correct = typeof value === type;
-        break;
-    case "bigInt":
-        correct = bigInt.isInstance(value) || value === undefined;
-        break;
-    case "true":
-        // true value is always correct
-        break;
-    case "buffer":
-        correct = Buffer.isBuffer(value);
-        break;
-    case "date":
-        correct =
-            (value &&
-                Object.prototype.toString.call(value) === "[object Date]" &&
-                !isNaN(value)) ||
-            typeof value === "number";
-        break;
-    default:
-        console.error(new Error("Unknown type." + type));
+        case "number":
+            correct = typeof value === "number" || value === undefined;
+            break;
+        case "string":
+        case "boolean":
+            correct = typeof value === type;
+            break;
+        case "bigInt":
+            correct = bigInt.isInstance(value) || value === undefined;
+            break;
+        case "true":
+            // true value is always correct
+            break;
+        case "buffer":
+            correct = Buffer.isBuffer(value);
+            break;
+        case "date":
+            correct =
+                (value &&
+                    Object.prototype.toString.call(value) === "[object Date]" &&
+                    !isNaN(value)) ||
+                typeof value === "number";
+            break;
+        default:
+            console.error(new Error("Unknown type." + type));
     }
     return correct;
 }
@@ -263,7 +263,7 @@ function createClasses(classesType, params) {
             argsConfig,
             namespace,
             isFunction,
-            result
+            result,
         } = classParams;
         const fullName = [namespace, name].join(".").replace(/^\./, "");
 
@@ -359,32 +359,32 @@ function createClasses(classesType, params) {
                     }
                 } else {
                     switch (object["type"]) {
-                    case "int":
-                        expected = "number";
-                        break;
-                    case "long":
-                    case "int128":
-                    case "int256":
-                    case "double":
-                        expected = "bigInt";
-                        break;
-                    case "string":
-                        expected = "string";
-                        break;
-                    case "Bool":
-                        expected = "boolean";
-                        break;
-                    case "true":
-                        expected = "true";
-                        break;
-                    case "bytes":
-                        expected = "buffer";
-                        break;
-                    case "date":
-                        expected = "date";
-                        break;
-                    default:
-                        expected = "object";
+                        case "int":
+                            expected = "number";
+                            break;
+                        case "long":
+                        case "int128":
+                        case "int256":
+                        case "double":
+                            expected = "bigInt";
+                            break;
+                        case "string":
+                            expected = "string";
+                            break;
+                        case "Bool":
+                            expected = "boolean";
+                            break;
+                        case "true":
+                            expected = "true";
+                            break;
+                        case "bytes":
+                            expected = "buffer";
+                            break;
+                        case "date":
+                            expected = "date";
+                            break;
+                        default:
+                            expected = "object";
                     }
                     if (expected === "object") {
                         // will be validated in get byte();

gramjs/tl/custom/message.ts

@@ -35,6 +35,7 @@ interface MessageBaseInterface {
     pinned?: any;
     restrictionReason?: any;
     forwards?: any;
+    ttlPeriod?: number;
     replies?: any;
     action?: any;
     _entities?: Map<number, Entity>;
@@ -60,15 +61,16 @@ export class Message extends Mixin(SenderGetter, ChatGetter) {
     media: any;
     replyMarkup: any | undefined;
     entities: any | undefined;
-    views: any | undefined;
+    views?: number;
     forwards: any | undefined;
     replies: any | undefined;
     editDate: any;
     pinned: any | undefined;
     postAuthor: any;
-    groupedId: any;
+    groupedId?: number;
     restrictionReason: any;
     action: any | undefined;
+    ttlPeriod?: number;
     _actionEntities: any;
     public _client?: TelegramClient;
     _text?: string;
@@ -118,7 +120,7 @@ export class Message extends Mixin(SenderGetter, ChatGetter) {
         replies = undefined,
 
         action = undefined,
-
+        ttlPeriod = undefined,
         _entities = new Map<number, Entity>(),
     }: MessageBaseInterface) {
         if (!id) throw new Error("id is a required attribute for Message");
@@ -138,9 +140,11 @@ export class Message extends Mixin(SenderGetter, ChatGetter) {
         this.mediaUnread = mediaUnread;
         this.silent = silent;
         this.post = post;
+        this.post = post;
         this.fromScheduled = fromScheduled;
         this.legacy = legacy;
         this.editHide = editHide;
+        this.ttlPeriod = ttlPeriod;
         this.id = id;
         this.fromId = fromId;
         this.peerId = peerId;