teleproto 203.0.0

package/tl/custom/file.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.File = void 0;
+const api_1 = require("../api");
+const Utils_1 = require("../../Utils");
+const Helpers_1 = require("../../Helpers");
+const inspect_1 = require("../../inspect");
+class File {
+    constructor(media) {
+        this.media = media;
+    }
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    get id() {
+        throw new Error("Unsupported");
+    }
+    get name() {
+        return this._fromAttr(api_1.Api.DocumentAttributeFilename, "fileName");
+    }
+    get mimeType() {
+        if (this.media instanceof api_1.Api.Photo) {
+            return "image/jpeg";
+        }
+        else if (this.media instanceof api_1.Api.Document) {
+            return this.media.mimeType;
+        }
+    }
+    get width() {
+        return this._fromAttr([api_1.Api.DocumentAttributeImageSize, api_1.Api.DocumentAttributeVideo], "w");
+    }
+    get height() {
+        return this._fromAttr([api_1.Api.DocumentAttributeImageSize, api_1.Api.DocumentAttributeVideo], "h");
+    }
+    get duration() {
+        return this._fromAttr([api_1.Api.DocumentAttributeAudio, api_1.Api.DocumentAttributeVideo], "duration");
+    }
+    get title() {
+        return this._fromAttr(api_1.Api.DocumentAttributeAudio, "title");
+    }
+    get performer() {
+        return this._fromAttr(api_1.Api.DocumentAttributeAudio, "performer");
+    }
+    get emoji() {
+        return this._fromAttr(api_1.Api.DocumentAttributeSticker, "alt");
+    }
+    get stickerSet() {
+        return this._fromAttr(api_1.Api.DocumentAttributeSticker, "stickerset");
+    }
+    get size() {
+        if (this.media instanceof api_1.Api.Photo) {
+            return (0, Utils_1._photoSizeByteCount)(this.media.sizes[this.media.sizes.length - 1]);
+        }
+        else if (this.media instanceof api_1.Api.Document) {
+            return this.media.size;
+        }
+    }
+    _fromAttr(cls, field) {
+        if (this.media instanceof api_1.Api.Document) {
+            for (const attr of this.media.attributes) {
+                if (attr instanceof cls) {
+                    return attr[field];
+                }
+            }
+        }
+    }
+}
+exports.File = File;

package/tl/custom/forward.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { ChatGetter } from "./chatGetter";
+import { SenderGetter } from "./senderGetter";
+import { Api } from "../api";
+import type { TelegramClient } from "../../client/TelegramClient";
+import type { Entity } from "../../define";
+import { inspect } from "../../inspect";
+export declare class Forward extends SenderGetter {
+    private originalFwd;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    constructor(client: TelegramClient, original: Api.MessageFwdHeader, entities: Map<string, Entity>);
+}
+export interface Forward extends ChatGetter, SenderGetter {
+}

package/tl/custom/forward.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Forward = void 0;
+const chatGetter_1 = require("./chatGetter");
+const senderGetter_1 = require("./senderGetter");
+const Helpers_1 = require("../../Helpers");
+const Utils_1 = require("../../Utils");
+const inspect_1 = require("../../inspect");
+class Forward extends senderGetter_1.SenderGetter {
+    constructor(client, original, entities) {
+        super();
+        // contains info for the original header sent by telegram.
+        this.originalFwd = original;
+        let senderId = undefined;
+        let sender = undefined;
+        let inputSender = undefined;
+        let peer = undefined;
+        let chat = undefined;
+        let inputChat = undefined;
+        if (original.fromId) {
+            const ty = (0, Helpers_1._entityType)(original.fromId);
+            if (ty === Helpers_1._EntityType.USER) {
+                senderId = (0, Utils_1.getPeerId)(original.fromId);
+                [sender, inputSender] = (0, Utils_1._getEntityPair)(senderId, entities, client._entityCache);
+            }
+            else if (ty === Helpers_1._EntityType.CHANNEL || ty === Helpers_1._EntityType.CHAT) {
+                peer = original.fromId;
+                [chat, inputChat] = (0, Utils_1._getEntityPair)((0, Utils_1.getPeerId)(peer), entities, client._entityCache);
+            }
+        }
+        chatGetter_1.ChatGetter.initChatClass(this, {
+            chatPeer: peer,
+            chat: chat,
+            inputChat: inputChat,
+        });
+        senderGetter_1.SenderGetter.initSenderClass(this, {
+            senderId: senderId ? (0, Helpers_1.returnBigInt)(senderId) : undefined,
+            sender: sender,
+            inputSender: inputSender,
+        });
+        this._client = client;
+    }
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+}
+exports.Forward = Forward;

package/tl/custom/index.d.ts

@@ -0,0 +1 @@
+export { ChatGetter } from "./chatGetter";

package/tl/custom/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatGetter = void 0;
+var chatGetter_1 = require("./chatGetter");
+Object.defineProperty(exports, "ChatGetter", { enumerable: true, get: function () { return chatGetter_1.ChatGetter; } });

package/tl/custom/inlineResult.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import type { TelegramClient } from "../..";
+import type { EntityLike, MessageIDLike } from "../../define";
+import { Api } from "../api";
+import { inspect } from "../../inspect";
+export declare class InlineResult {
+    private _ARTICLE;
+    private _PHOTO;
+    private _GIF;
+    private _VIDEO;
+    private _VIDEO_GIF;
+    private _AUDIO;
+    private _DOCUMENT;
+    private _LOCATION;
+    private _VENUE;
+    private _CONTACT;
+    private _GAME;
+    private readonly _entity;
+    private readonly _queryId;
+    private readonly result;
+    private _client;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    constructor(client: TelegramClient, original: Api.TypeBotInlineResult, queryId?: Api.long, entity?: EntityLike);
+    get type(): string;
+    get message(): Api.TypeBotInlineMessage;
+    get description(): string | undefined;
+    get url(): string | undefined;
+    get photo(): Api.TypePhoto | Api.TypeWebDocument | undefined;
+    get document(): Api.TypeDocument | Api.TypeWebDocument | undefined;
+    click(entity?: EntityLike, replyTo?: MessageIDLike, silent?: boolean, clearDraft?: boolean, hideVia?: boolean): Promise<Api.TypeUpdates>;
+}

package/tl/custom/inlineResult.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlineResult = void 0;
+const api_1 = require("../api");
+const Helpers_1 = require("../../Helpers");
+const inspect_1 = require("../../inspect");
+const Utils_1 = require("../../Utils");
+class InlineResult {
+    constructor(client, original, queryId, entity) {
+        this._ARTICLE = "article";
+        this._PHOTO = "photo";
+        this._GIF = "gif";
+        this._VIDEO = "video";
+        this._VIDEO_GIF = "mpeg4_gif";
+        this._AUDIO = "audio";
+        this._DOCUMENT = "document";
+        this._LOCATION = "location";
+        this._VENUE = "venue";
+        this._CONTACT = "contact";
+        this._GAME = "game";
+        this._client = client;
+        this.result = original;
+        this._queryId = queryId;
+        this._entity = entity;
+    }
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    get type() {
+        return this.result.type;
+    }
+    get message() {
+        return this.result.sendMessage;
+    }
+    get description() {
+        return this.result.description;
+    }
+    get url() {
+        if (this.result instanceof api_1.Api.BotInlineResult) {
+            return this.result.url;
+        }
+    }
+    get photo() {
+        if (this.result instanceof api_1.Api.BotInlineResult) {
+            return this.result.thumb;
+        }
+        else {
+            return this.result.photo;
+        }
+    }
+    get document() {
+        if (this.result instanceof api_1.Api.BotInlineResult) {
+            return this.result.content;
+        }
+        else {
+            return this.result.document;
+        }
+    }
+    async click(entity, replyTo, silent = false, clearDraft = false, hideVia = false) {
+        if (entity) {
+            entity = await this._client.getInputEntity(entity);
+        }
+        else if (this._entity) {
+            entity = this._entity;
+        }
+        else {
+            throw new Error("You must provide the entity where the result should be sent to");
+        }
+        let replyObject = undefined;
+        if (replyTo != undefined) {
+            replyObject = new api_1.Api.InputReplyToMessage({
+                replyToMsgId: (0, Utils_1.getMessageId)(replyTo),
+            });
+        }
+        const request = new api_1.Api.messages.SendInlineBotResult({
+            peer: entity,
+            queryId: this._queryId,
+            id: this.result.id,
+            silent: silent,
+            clearDraft: clearDraft,
+            hideVia: hideVia,
+            replyTo: replyObject,
+        });
+        return await this._client.invoke(request);
+    }
+}
+exports.InlineResult = InlineResult;

package/tl/custom/inlineResults.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import type { TelegramClient } from "../..";
+import type { EntityLike } from "../../define";
+import { Api } from "../api";
+import { InlineResult } from "./inlineResult";
+import { inspect } from "../../inspect";
+export declare class InlineResults extends Array<InlineResult> {
+    private result;
+    private queryId;
+    private readonly cacheTime;
+    private readonly _validUntil;
+    private users;
+    private gallery;
+    private nextOffset;
+    private switchPm;
+    [inspect.custom](): {
+        [key: string]: any;
+    };
+    constructor(client: TelegramClient, original: Api.messages.TypeBotResults, entity?: EntityLike);
+    resultsValid(): boolean;
+}

package/tl/custom/inlineResults.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InlineResults = void 0;
+const inlineResult_1 = require("./inlineResult");
+const Helpers_1 = require("../../Helpers");
+const inspect_1 = require("../../inspect");
+class InlineResults extends Array {
+    constructor(client, original, entity) {
+        super(...original.results.map((res) => new inlineResult_1.InlineResult(client, res, original.queryId, entity)));
+        this.result = original;
+        this.queryId = original.queryId;
+        this.cacheTime = original.cacheTime;
+        this._validUntil = new Date().getTime() / 1000 + this.cacheTime;
+        this.users = original.users;
+        this.gallery = Boolean(original.gallery);
+        this.nextOffset = original.nextOffset;
+        this.switchPm = original.switchPm;
+    }
+    [inspect_1.inspect.custom]() {
+        return (0, Helpers_1.betterConsoleLog)(this);
+    }
+    resultsValid() {
+        return new Date().getTime() / 1000 < this._validUntil;
+    }
+}
+exports.InlineResults = InlineResults;