teleproto 203.0.0

package/tl/core/GZIPPacked.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import type { BinaryReader } from "../../extensions";
+export declare class GZIPPacked {
+    static CONSTRUCTOR_ID: number;
+    static classType: string;
+    data: Buffer;
+    private CONSTRUCTOR_ID;
+    private classType;
+    constructor(data: Buffer);
+    static gzipIfSmaller(contentRelated: boolean, data: Buffer): Promise<Buffer>;
+    static gzip(input: Buffer): Buffer;
+    static ungzip(input: Buffer): Buffer;
+    toBytes(): Promise<Buffer>;
+    static read(reader: BinaryReader): Promise<Buffer>;
+    static fromReader(reader: BinaryReader): Promise<GZIPPacked>;
+}

package/tl/core/GZIPPacked.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GZIPPacked = void 0;
+const __1 = require("..");
+const pako_1 = require("pako");
+class GZIPPacked {
+    constructor(data) {
+        this.data = data;
+        this.CONSTRUCTOR_ID = 0x3072cfa1;
+        this.classType = "constructor";
+    }
+    static async gzipIfSmaller(contentRelated, data) {
+        if (contentRelated && data.length > 512) {
+            const gzipped = await new GZIPPacked(data).toBytes();
+            if (gzipped.length < data.length) {
+                return gzipped;
+            }
+        }
+        return data;
+    }
+    static gzip(input) {
+        return Buffer.from(input);
+        // TODO this usually makes it faster for large requests
+        //return Buffer.from(deflate(input, { level: 9, gzip: true }))
+    }
+    static ungzip(input) {
+        return Buffer.from((0, pako_1.inflate)(input));
+    }
+    async toBytes() {
+        const g = Buffer.alloc(4);
+        g.writeUInt32LE(GZIPPacked.CONSTRUCTOR_ID, 0);
+        return Buffer.concat([
+            g,
+            (0, __1.serializeBytes)(await GZIPPacked.gzip(this.data)),
+        ]);
+    }
+    static async read(reader) {
+        const constructor = reader.readInt(false);
+        if (constructor !== GZIPPacked.CONSTRUCTOR_ID) {
+            throw new Error("not equal");
+        }
+        return GZIPPacked.gzip(reader.tgReadBytes());
+    }
+    static async fromReader(reader) {
+        const data = reader.tgReadBytes();
+        return new GZIPPacked(await GZIPPacked.ungzip(data));
+    }
+}
+exports.GZIPPacked = GZIPPacked;
+GZIPPacked.CONSTRUCTOR_ID = 0x3072cfa1;
+GZIPPacked.classType = "constructor";

package/tl/core/MessageContainer.d.ts

@@ -0,0 +1,12 @@
+import type { BinaryReader } from "../../extensions";
+export declare class MessageContainer {
+    static CONSTRUCTOR_ID: number;
+    static classType: string;
+    static MAXIMUM_SIZE: number;
+    static MAXIMUM_LENGTH: number;
+    private CONSTRUCTOR_ID;
+    private messages;
+    private classType;
+    constructor(messages: any[]);
+    static fromReader(reader: BinaryReader): Promise<MessageContainer>;
+}

package/tl/core/MessageContainer.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageContainer = void 0;
+const TLMessage_1 = require("./TLMessage");
+class MessageContainer {
+    constructor(messages) {
+        this.CONSTRUCTOR_ID = 0x73f1f8dc;
+        this.messages = messages;
+        this.classType = "constructor";
+    }
+    static async fromReader(reader) {
+        const messages = [];
+        const length = reader.readInt();
+        for (let x = 0; x < length; x++) {
+            const msgId = reader.readLong();
+            const seqNo = reader.readInt();
+            const length = reader.readInt();
+            const before = reader.tellPosition();
+            const obj = reader.tgReadObject();
+            reader.setPosition(before + length);
+            const tlMessage = new TLMessage_1.TLMessage(msgId, seqNo, obj);
+            messages.push(tlMessage);
+        }
+        return new MessageContainer(messages);
+    }
+}
+exports.MessageContainer = MessageContainer;
+MessageContainer.CONSTRUCTOR_ID = 0x73f1f8dc;
+MessageContainer.classType = "constructor";
+// Maximum size in bytes for the inner payload of the container.
+// Telegram will close the connection if the payload is bigger.
+// The overhead of the container itself is subtracted.
+MessageContainer.MAXIMUM_SIZE = 1044456 - 8;
+// Maximum amount of messages that can't be sent inside a single
+// container, inclusive. Beyond this limit Telegram will respond
+// with BAD_MESSAGE 64 (invalid container).
+//
+// This limit is not 100% accurate and may in some cases be higher.
+// However, sending up to 100 requests at once in a single container
+// is a reasonable conservative value, since it could also depend on
+// other factors like size per request, but we cannot know this.
+MessageContainer.MAXIMUM_LENGTH = 100;

package/tl/core/RPCResult.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { Api } from "../api";
+import type { BinaryReader } from "../../extensions";
+import bigInt from "big-integer";
+export declare class RPCResult {
+    static CONSTRUCTOR_ID: number;
+    static classType: string;
+    private CONSTRUCTOR_ID;
+    private reqMsgId;
+    private body?;
+    private error?;
+    private classType;
+    constructor(reqMsgId: bigInt.BigInteger, body?: Buffer, error?: Api.RpcError);
+    static fromReader(reader: BinaryReader): Promise<RPCResult>;
+}

package/tl/core/RPCResult.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RPCResult = void 0;
+const api_1 = require("../api");
+const _1 = require(".");
+class RPCResult {
+    constructor(reqMsgId, body, error) {
+        this.CONSTRUCTOR_ID = 0xf35c6d01;
+        this.reqMsgId = reqMsgId;
+        this.body = body;
+        this.error = error;
+        this.classType = "constructor";
+    }
+    static async fromReader(reader) {
+        const msgId = reader.readLong();
+        const innerCode = reader.readInt(false);
+        if (innerCode === api_1.Api.RpcError.CONSTRUCTOR_ID) {
+            return new RPCResult(msgId, undefined, api_1.Api.RpcError.fromReader(reader));
+        }
+        if (innerCode === _1.GZIPPacked.CONSTRUCTOR_ID) {
+            return new RPCResult(msgId, (await _1.GZIPPacked.fromReader(reader)).data);
+        }
+        reader.seek(-4);
+        // This reader.read() will read more than necessary, but it's okay.
+        // We could make use of MessageContainer's length here, but since
+        // it's not necessary we don't need to care about it.
+        return new RPCResult(msgId, reader.read(), undefined);
+    }
+}
+exports.RPCResult = RPCResult;
+RPCResult.CONSTRUCTOR_ID = 0xf35c6d01;
+RPCResult.classType = "constructor";

package/tl/core/TLMessage.d.ts

@@ -0,0 +1,10 @@
+import bigInt from "big-integer";
+export declare class TLMessage {
+    static SIZE_OVERHEAD: number;
+    static classType: string;
+    msgId: bigInt.BigInteger;
+    private classType;
+    private seqNo;
+    obj: any;
+    constructor(msgId: bigInt.BigInteger, seqNo: number, obj: any);
+}

package/tl/core/TLMessage.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TLMessage = void 0;
+class TLMessage {
+    constructor(msgId, seqNo, obj) {
+        this.msgId = msgId;
+        this.seqNo = seqNo;
+        this.obj = obj;
+        this.classType = "constructor";
+    }
+}
+exports.TLMessage = TLMessage;
+TLMessage.SIZE_OVERHEAD = 12;
+TLMessage.classType = "constructor";

package/tl/core/index.d.ts

@@ -0,0 +1,6 @@
+import { TLMessage } from "./TLMessage";
+import { RPCResult } from "./RPCResult";
+import { MessageContainer } from "./MessageContainer";
+import { GZIPPacked } from "./GZIPPacked";
+export declare const coreObjects: Map<number, Function>;
+export { RPCResult, TLMessage, MessageContainer, GZIPPacked };

package/tl/core/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GZIPPacked = exports.MessageContainer = exports.TLMessage = exports.RPCResult = exports.coreObjects = void 0;
+const TLMessage_1 = require("./TLMessage");
+Object.defineProperty(exports, "TLMessage", { enumerable: true, get: function () { return TLMessage_1.TLMessage; } });
+const RPCResult_1 = require("./RPCResult");
+Object.defineProperty(exports, "RPCResult", { enumerable: true, get: function () { return RPCResult_1.RPCResult; } });
+const MessageContainer_1 = require("./MessageContainer");
+Object.defineProperty(exports, "MessageContainer", { enumerable: true, get: function () { return MessageContainer_1.MessageContainer; } });
+const GZIPPacked_1 = require("./GZIPPacked");
+Object.defineProperty(exports, "GZIPPacked", { enumerable: true, get: function () { return GZIPPacked_1.GZIPPacked; } });
+exports.coreObjects = new Map([
+    [RPCResult_1.RPCResult.CONSTRUCTOR_ID, RPCResult_1.RPCResult],
+    [GZIPPacked_1.GZIPPacked.CONSTRUCTOR_ID, GZIPPacked_1.GZIPPacked],
+    [MessageContainer_1.MessageContainer.CONSTRUCTOR_ID, MessageContainer_1.MessageContainer],
+]);

package/tl/custom/button.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import type { ButtonLike, EntityLike } from "../../define";
+import { Api } from "../api";
+import { inspect } from "../../inspect";
+export declare class Button {
+    button: ButtonLike;
+    resize: boolean | undefined;
+    selective: boolean | undefined;
+    singleUse: boolean | undefined;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    constructor(button: Api.TypeKeyboardButton, resize?: boolean, singleUse?: boolean, selective?: boolean);
+    static _isInline(button: ButtonLike): boolean;
+    static inline(text: string, data?: Buffer): Api.KeyboardButtonCallback;
+    static switchInline(text: string, query?: string, samePeer?: boolean): Api.KeyboardButtonSwitchInline;
+    static url(text: string, url?: string): Api.KeyboardButtonUrl;
+    static auth(text: string, url?: string, bot?: EntityLike, writeAccess?: boolean, fwdText?: string): Api.InputKeyboardButtonUrlAuth;
+    static text(text: string, resize?: boolean, singleUse?: boolean, selective?: boolean): Button;
+    static requestLocation(text: string, resize?: boolean, singleUse?: boolean, selective?: boolean): Button;
+    static requestPhone(text: string, resize?: boolean, singleUse?: boolean, selective?: boolean): Button;
+    static requestPoll(text: string, resize?: boolean, singleUse?: boolean, selective?: boolean): Button;
+    static clear(): Api.ReplyKeyboardHide;
+    static forceReply(): Api.ReplyKeyboardForceReply;
+}

package/tl/custom/button.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Button = void 0;
+const api_1 = require("../api");
+const __1 = require("../..");
+const Helpers_1 = require("../../Helpers");
+const inspect_1 = require("../../inspect");
+class Button {
+    constructor(button, resize, singleUse, selective) {
+        this.button = button;
+        this.resize = resize;
+        this.singleUse = singleUse;
+        this.selective = selective;
+    }
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    static _isInline(button) {
+        return (button instanceof api_1.Api.KeyboardButtonCallback ||
+            button instanceof api_1.Api.KeyboardButtonSwitchInline ||
+            button instanceof api_1.Api.KeyboardButtonUrl ||
+            button instanceof api_1.Api.KeyboardButtonUrlAuth ||
+            button instanceof api_1.Api.InputKeyboardButtonUrlAuth);
+    }
+    static inline(text, data) {
+        if (!data) {
+            data = Buffer.from(text, "utf-8");
+        }
+        if (data.length > 64) {
+            throw new Error("Too many bytes for the data");
+        }
+        return new api_1.Api.KeyboardButtonCallback({
+            text: text,
+            data: data,
+        });
+    }
+    static switchInline(text, query = "", samePeer = false) {
+        return new api_1.Api.KeyboardButtonSwitchInline({
+            text,
+            query,
+            samePeer,
+        });
+    }
+    static url(text, url) {
+        return new api_1.Api.KeyboardButtonUrl({
+            text: text,
+            url: url || text,
+        });
+    }
+    static auth(text, url, bot, writeAccess, fwdText) {
+        return new api_1.Api.InputKeyboardButtonUrlAuth({
+            text,
+            url: url || text,
+            bot: __1.utils.getInputUser(bot || new api_1.Api.InputUserSelf()),
+            requestWriteAccess: writeAccess,
+            fwdText: fwdText,
+        });
+    }
+    static text(text, resize, singleUse, selective) {
+        return new this(new api_1.Api.KeyboardButton({ text }), resize, singleUse, selective);
+    }
+    static requestLocation(text, resize, singleUse, selective) {
+        return new this(new api_1.Api.KeyboardButtonRequestGeoLocation({ text }), resize, singleUse, selective);
+    }
+    static requestPhone(text, resize, singleUse, selective) {
+        return new this(new api_1.Api.KeyboardButtonRequestPhone({ text }), resize, singleUse, selective);
+    }
+    static requestPoll(text, resize, singleUse, selective) {
+        return new this(new api_1.Api.KeyboardButtonRequestPoll({ text }), resize, singleUse, selective);
+    }
+    static clear() {
+        return new api_1.Api.ReplyKeyboardHide({});
+    }
+    static forceReply() {
+        return new api_1.Api.ReplyKeyboardForceReply({});
+    }
+}
+exports.Button = Button;

package/tl/custom/chatGetter.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+import type { Entity, EntityLike } from "../../define";
+import type { TelegramClient } from "../../client/TelegramClient";
+import { inspect } from "../../inspect";
+export interface ChatGetterConstructorParams {
+    chatPeer?: EntityLike;
+    inputChat?: EntityLike;
+    chat?: EntityLike;
+    broadcast?: boolean;
+}
+export declare class ChatGetter {
+    _chatPeer?: EntityLike;
+    _inputChat?: EntityLike;
+    _chat?: Entity;
+    _broadcast?: boolean;
+    _client?: TelegramClient;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    static initChatClass(c: any, { chatPeer, inputChat, chat, broadcast }: ChatGetterConstructorParams): void;
+    get chat(): Entity | undefined;
+    getChat(): Promise<Entity | undefined>;
+    get inputChat(): EntityLike | undefined;
+    getInputChat(): Promise<EntityLike | undefined>;
+    get chatId(): import("big-integer").BigInteger | undefined;
+    get isPrivate(): boolean | undefined;
+    get isGroup(): boolean | undefined;
+    get isChannel(): boolean;
+    _refetchChat(): Promise<void>;
+}

package/tl/custom/chatGetter.js

@@ -0,0 +1,114 @@
+"use strict";
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatGetter = void 0;
+const __1 = require("../..");
+const api_1 = require("../api");
+const Helpers_1 = require("../../Helpers");
+const inspect_1 = require("../../inspect");
+class ChatGetter {
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    static initChatClass(c, { chatPeer, inputChat, chat, broadcast }) {
+        c._chatPeer = chatPeer;
+        c._inputChat = inputChat;
+        c._chat = chat;
+        c._broadcast = broadcast;
+        c._client = undefined;
+    }
+    get chat() {
+        return this._chat;
+    }
+    async getChat() {
+        var _a;
+        if (!this._chat ||
+            ("min" in this._chat && (await this.getInputChat()))) {
+            try {
+                if (this._inputChat) {
+                    this._chat = await ((_a = this._client) === null || _a === void 0 ? void 0 : _a.getEntity(this._inputChat));
+                }
+            }
+            catch (e) {
+                await this._refetchChat();
+            }
+        }
+        return this._chat;
+    }
+    get inputChat() {
+        if (!this._inputChat && this._chatPeer && this._client) {
+            try {
+                this._inputChat = this._client._entityCache.get(__1.utils.getPeerId(this._chatPeer));
+            }
+            catch (e) { }
+        }
+        return this._inputChat;
+    }
+    async getInputChat() {
+        var e_1, _a;
+        if (!this.inputChat && this.chatId && this._client) {
+            try {
+                const target = this.chatId;
+                try {
+                    for (var _b = __asyncValues(this._client.iterDialogs({
+                        limit: 100,
+                    })), _c; _c = await _b.next(), !_c.done;) {
+                        const dialog = _c.value;
+                        if (dialog.id.eq(target)) {
+                            this._chat = dialog.entity;
+                            this._inputChat = dialog.inputEntity;
+                            break;
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) await _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (e) {
+                // do nothing
+            }
+            return this._inputChat;
+        }
+        return this._inputChat;
+    }
+    get chatId() {
+        return this._chatPeer
+            ? (0, Helpers_1.returnBigInt)(__1.utils.getPeerId(this._chatPeer))
+            : undefined;
+    }
+    get isPrivate() {
+        return this._chatPeer
+            ? this._chatPeer instanceof api_1.Api.PeerUser
+            : undefined;
+    }
+    get isGroup() {
+        if (!this._broadcast && this.chat && "broadcast" in this.chat) {
+            this._broadcast = Boolean(this.chat.broadcast);
+        }
+        if (this._chatPeer instanceof api_1.Api.PeerChannel) {
+            if (this._broadcast === undefined) {
+                return undefined;
+            }
+            else {
+                return !this._broadcast;
+            }
+        }
+        return this._chatPeer instanceof api_1.Api.PeerChat;
+    }
+    get isChannel() {
+        return this._chatPeer instanceof api_1.Api.PeerChannel;
+    }
+    async _refetchChat() { }
+}
+exports.ChatGetter = ChatGetter;

package/tl/custom/dialog.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import type { TelegramClient } from "../..";
+import { Api } from "../api";
+import type { Entity } from "../../define";
+import { Draft } from "./draft";
+import bigInt from "big-integer";
+import { inspect } from "../../inspect";
+export declare class Dialog {
+    _client: TelegramClient;
+    dialog: Api.Dialog;
+    pinned: boolean;
+    folderId?: number;
+    archived: boolean;
+    message?: Api.Message;
+    date: number;
+    entity?: Entity;
+    inputEntity: Api.TypeInputPeer;
+    id?: bigInt.BigInteger;
+    name?: string;
+    title?: string;
+    unreadCount: number;
+    unreadMentionsCount: number;
+    draft: Draft;
+    isUser: boolean;
+    isGroup: boolean;
+    isChannel: boolean;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    constructor(client: TelegramClient, dialog: Api.Dialog, entities: Map<string, Entity>, message?: Api.Message);
+}

package/tl/custom/dialog.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Dialog = void 0;
+const api_1 = require("../api");
+const Utils_1 = require("../../Utils");
+const draft_1 = require("./draft");
+const Helpers_1 = require("../../Helpers");
+const inspect_1 = require("../../inspect");
+class Dialog {
+    constructor(client, dialog, entities, message) {
+        this._client = client;
+        this.dialog = dialog;
+        this.pinned = !!dialog.pinned;
+        this.folderId = dialog.folderId;
+        this.archived = dialog.folderId != undefined;
+        this.message = message;
+        this.date = this.message.date;
+        this.entity = entities.get((0, Utils_1.getPeerId)(dialog.peer));
+        this.inputEntity = (0, Utils_1.getInputPeer)(this.entity);
+        if (this.entity) {
+            this.id = (0, Helpers_1.returnBigInt)((0, Utils_1.getPeerId)(this.entity)); // ^ May be InputPeerSelf();
+            this.name = this.title = (0, Utils_1.getDisplayName)(this.entity);
+        }
+        this.unreadCount = dialog.unreadCount;
+        this.unreadMentionsCount = dialog.unreadMentionsCount;
+        if (!this.entity) {
+            throw new Error("Entity not found for dialog");
+        }
+        this.draft = new draft_1.Draft(client, this.entity, this.dialog.draft);
+        this.isUser = this.entity instanceof api_1.Api.User;
+        this.isGroup = !!(this.entity instanceof api_1.Api.Chat ||
+            this.entity instanceof api_1.Api.ChatForbidden ||
+            (this.entity instanceof api_1.Api.Channel && this.entity.megagroup));
+        this.isChannel = this.entity instanceof api_1.Api.Channel;
+    }
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+}
+exports.Dialog = Dialog;

package/tl/custom/draft.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { Entity } from "../../define";
+import type { TelegramClient } from "../..";
+import { Api } from "../api";
+import { inspect } from "../../inspect";
+export declare class Draft {
+    private _client;
+    private readonly _entity?;
+    private readonly _peer;
+    private _inputEntity;
+    private _text?;
+    private _rawText?;
+    private date?;
+    private linkPreview?;
+    private replyToMsgId?;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    constructor(client: TelegramClient, entity: Entity, draft: Api.TypeDraftMessage | undefined);
+    get entity(): Entity | undefined;
+    get inputEntity(): Api.TypeInputPeer | undefined;
+}

package/tl/custom/draft.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Draft = void 0;
+const Utils_1 = require("../../Utils");
+const api_1 = require("../api");
+const Helpers_1 = require("../../Helpers");
+const inspect_1 = require("../../inspect");
+class Draft {
+    constructor(client, entity, draft) {
+        this._client = client;
+        this._peer = (0, Utils_1.getPeer)(entity);
+        this._entity = entity;
+        this._inputEntity = entity ? (0, Utils_1.getInputPeer)(entity) : undefined;
+        if (!draft || !(draft instanceof api_1.Api.DraftMessage)) {
+            draft = new api_1.Api.DraftMessage({
+                message: "",
+                date: -1,
+            });
+        }
+        if (!(draft instanceof api_1.Api.DraftMessageEmpty)) {
+            this.linkPreview = !draft.noWebpage;
+            this._text = client.parseMode
+                ? client.parseMode.unparse(draft.message, draft.entities || [])
+                : draft.message;
+            this._rawText = draft.message;
+            this.date = draft.date;
+            const replyTo = draft.replyTo;
+            if (replyTo != undefined) {
+                if ("replyToMsgId" in replyTo) {
+                    this.replyToMsgId = replyTo.replyToMsgId;
+                }
+            }
+        }
+    }
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    get entity() {
+        return this._entity;
+    }
+    get inputEntity() {
+        if (!this._inputEntity) {
+            this._inputEntity = this._client._entityCache.get(this._peer);
+        }
+        return this._inputEntity;
+    }
+}
+exports.Draft = Draft;

package/tl/custom/file.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { FileLike } from "../../define";
+import { inspect } from "../../inspect";
+export declare class File {
+    private readonly media;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    constructor(media: FileLike);
+    get id(): void;
+    get name(): any;
+    get mimeType(): string | undefined;
+    get width(): any;
+    get height(): any;
+    get duration(): any;
+    get title(): any;
+    get performer(): any;
+    get emoji(): any;
+    get stickerSet(): any;
+    get size(): number | import("big-integer").BigInteger | undefined;
+    _fromAttr(cls: any, field: string): any;
+}