@mtcute/core 0.18.0-rc.5 → 0.18.0

package/highlevel/types/media/web-page.d.cts

@@ -0,0 +1,151 @@
+import { tl } from '@mtcute/tl';
+import { RawDocument } from './document.js';
+import { Photo } from './photo.js';
+/**
+ * Web page preview.
+ *
+ * **Warning**: Documentation of this class also contains my
+ * personal research about how Telegram
+ * handles different pages and embeds. **By no means**
+ * this should be considered the definitive source of truth,
+ * as this is not documented officially, and only consists
+ * of my own observations and experiments.
+ */
+export declare class WebPage {
+    readonly raw: tl.RawWebPage;
+    readonly type: "webpage";
+    constructor(raw: tl.RawWebPage);
+    /**
+     * Unique ID of the preview
+     */
+    get id(): tl.Long;
+    /**
+     * Original page URL
+     */
+    get url(): string;
+    /**
+     * URL to be displayed to the user.
+     *
+     * Usually a normal URL with stripped protocol and garbage.
+     */
+    get displayUrl(): string;
+    /**
+     * Type of the preview, taken directly from TL object
+     *
+     * Officially documented are:
+     * `article, photo, audio, video, document, profile, app`,
+     * but also these are encountered:
+     * `telegram_user, telegram_bot, telegram_channel, telegram_megagroup, telegram_story`:
+     *
+     * - `telegram_*` ones seem to be used for `t.me` links.
+     * - `article` seems to be used for almost all custom pages with `og:*` tags
+     * - `photo`, `audio` and `video` seem to be derived from `og:type`,
+     *    and the page itself may contain a preview photo and an embed link
+     *    for the player. This may not correctly represent actual content type:
+     *    Spotify links are `audio`, but SoundCloud are `video`. YouTube links are `video`,
+     *    but tweets with video are `photo`.
+     * - `document` seem to be used for files downloadable directly from the URL,
+     *    like PDFs, audio files, videos, etc. {@link document} seem to be
+     *    present if `type` is `document`.
+     * - `profile` doesn't seem to be used
+     * - `app` doesn't seem to be used
+     *
+     * `unknown` is returned if no type is returned in the TL object.
+     */
+    get previewType(): string;
+    /**
+     * Page title
+     *
+     * Usually defined by `og:site_name` meta tag or website domain
+     */
+    get siteName(): string | null;
+    /**
+     * Page title
+     *
+     * Usually defined by `og:title` meta tag or `<title>` tag
+     */
+    get title(): string | null;
+    /**
+     * Page description
+     *
+     * Usually defined by `description` or `og:description` meta tag
+     */
+    get description(): string | null;
+    /**
+     * Page author
+     *
+     * The source for this is unknown, seems to be
+     * custom-made for services like Twitter.
+     *
+     * In official apps this seems to be used as a fallback for description.
+     */
+    get author(): string | null;
+    /**
+     * The embed URL.
+     *
+     * Based on my research, Telegram only allows
+     * embedding pages from a server-side white-list of domains.
+     *
+     * That is, you can't just copy-paste meta tags
+     * from YouTube to your own domain and expect Telegram
+     * to return a webpage with embed.
+     *
+     * IDK why is that, maybe they are concerned about
+     * leaking users' IPs to 3rd parties or something
+     * (but why allow embedding in the first place then?)
+     *
+     * Telegram for Android does not show "play" button for
+     * webpages without embeds, and instead treats it like a simple
+     * photo (why?).
+     *
+     * TDesktop does not support embeds and seems
+     * to use {@link type} to determine them, and specifically
+     * [checks](https://github.com/telegramdesktop/tdesktop/blob/3343880ed0e5a86accc7334af54b3470e29ee686/Telegram/SourceFiles/history/view/media/history_view_web_page.cpp#L561)
+     * for `YouTube` in {@link siteName} to display YouTube icon.
+     */
+    get embedUrl(): string | null;
+    /**
+     * Embed type.
+     *
+     * Now this is actually stupid.
+     * As per [official documentation](https://core.telegram.org/constructor/webPage),
+     * `embed_type` contains «MIME type of the embedded preview, (e.g., text/html or video/mp4)».
+     * But in fact every time I encountered it it contained a simple string `iframe`.
+     *
+     * I couldn't find any usage of this field in official apps either.
+     */
+    get embedType(): string | null;
+    /**
+     * Width of the embed in pixels, 0 if not available.
+     */
+    get embedWidth(): number;
+    /**
+     * Height of the embed in pixels, 0 if not available.
+     */
+    get embedHeight(): number;
+    /**
+     * A photo inside this webpage preview.
+     *
+     * Used for most of the preview types.
+     */
+    get photo(): Photo | null;
+    /**
+     * Document inside this webpage preview.
+     *
+     * Seems that this is only used for `document` previews.
+     *
+     * Can be a {@link Photo}, {@link Video},
+     * {@link Audio}, {@link Document}.
+     */
+    get document(): RawDocument | null;
+    /**
+     * Input media TL object generated from this object,
+     * to be used inside {@link InputMediaLike} and
+     * {@link TelegramClient.sendMedia}.
+     *
+     * WebPage can't provide an input media, since some
+     * can only be auto-generated from a link. This getter
+     * is only provided to allow using `msg.media.inputMedia`
+     */
+    get inputMedia(): tl.TypeInputMedia;
+}

package/highlevel/types/messages/dialog.d.cts

@@ -0,0 +1,110 @@
+import { tl } from '@mtcute/tl';
+import { Peer } from '../peers/peer.js';
+import { PeersIndex } from '../peers/peers-index.js';
+import { DraftMessage } from './draft-message.js';
+import { Message } from './message.js';
+/**
+ * Type used as an input for a folder in client methods
+ *
+ * You can pass folder object, id or title
+ */
+export type InputDialogFolder = string | number | tl.RawDialogFilter;
+/**
+ * A dialog.
+ *
+ * Think of it as something that is listed
+ * in Telegram's main window.
+ */
+export declare class Dialog {
+    readonly raw: tl.RawDialog;
+    readonly _peers: PeersIndex;
+    readonly _messages: Map<number, tl.TypeMessage>;
+    constructor(raw: tl.RawDialog, _peers: PeersIndex, _messages: Map<number, tl.TypeMessage>);
+    /**
+     * Parse a list of dialogs from a TL object
+     *
+     * @param client  Client instance
+     * @param dialogs  TL object
+     * @param limit  Maximum number of dialogs to parse
+     */
+    static parseTlDialogs(dialogs: tl.messages.TypeDialogs | tl.messages.TypePeerDialogs, limit?: number): Dialog[];
+    /**
+     * Find pinned dialogs from a list of dialogs
+     *
+     * @param dialogs  Dialogs list
+     * @param folder  If passed, status of pin will be checked against this folder, and not globally
+     */
+    static findPinned(dialogs: Dialog[], folder?: tl.RawDialogFilter): Dialog[];
+    /**
+     * Create a filter predicate for the given Folder.
+     * Returned predicate can be used in `Array.filter()`
+     *
+     * @param folder  Folder to filter for
+     * @param excludePinned  Whether to exclude pinned folders
+     */
+    static filterFolder(folder: tl.TypeDialogFilter, excludePinned?: boolean): (val: Dialog) => boolean;
+    /**
+     * Whether this dialog is pinned
+     */
+    get isPinned(): boolean;
+    /**
+     * Whether this chat was manually marked as unread
+     */
+    get isManuallyUnread(): boolean;
+    /**
+     * Whether this chat should be considered unread
+     * (i.e. has more than 1 unread message, or has
+     * a "manually unread" mark)
+     */
+    get isUnread(): boolean;
+    /**
+     * Whether this dialog is muted.
+     *
+     * If `null`, the default account-level setting should be used.
+     */
+    get isMuted(): boolean | null;
+    /**
+     * Whether this dialog is archived
+     */
+    get isArchived(): boolean;
+    /**
+     * Peer that this dialog represents
+     */
+    get peer(): Peer;
+    /**
+     * The latest message sent in this chat (if any)
+     */
+    get lastMessage(): Message | null;
+    /**
+     * ID of the last read outgoing message in this dialog
+     */
+    get lastReadOutgoing(): number;
+    /**
+     * ID of the last read ingoing message in this dialog
+     */
+    get lastReadIngoing(): number;
+    /**
+     * ID of the last read message in this dialog
+     */
+    get lastRead(): number;
+    /**
+     * Number of unread messages
+     */
+    get unreadCount(): number;
+    /**
+     * Number of unread mentions
+     */
+    get unreadMentionsCount(): number;
+    /**
+     * Number of unread reactions
+     */
+    get unreadReactionsCount(): number;
+    /**
+     * Draft message in this dialog
+     */
+    get draftMessage(): DraftMessage | null;
+    /**
+     * TTL period of all messages in this dialog
+     */
+    get ttlPeriod(): number | null;
+}

package/highlevel/types/messages/draft-message.d.cts

@@ -0,0 +1,29 @@
+import { tl } from '@mtcute/tl';
+import { MessageEntity } from './message-entity.js';
+/**
+ * A draft message
+ */
+export declare class DraftMessage {
+    readonly raw: tl.RawDraftMessage;
+    constructor(raw: tl.RawDraftMessage);
+    /**
+     * Text of the draft message
+     */
+    get text(): string;
+    /**
+     * Information about replies/quotes in this message
+     */
+    get replyToMessage(): tl.RawInputReplyToMessage | null;
+    /**
+     * Date of the last time this draft was updated
+     */
+    get date(): Date;
+    /**
+     * Whether no webpage preview will be generated
+     */
+    get disableWebPreview(): boolean;
+    /**
+     * Message text entities (may be empty)
+     */
+    get entities(): ReadonlyArray<MessageEntity>;
+}

package/highlevel/types/messages/fact-check.d.cts

@@ -0,0 +1,30 @@
+import { tl } from '@mtcute/tl';
+import { MessageEntity } from './message-entity.js';
+/**
+ * Describes a fact-check added to the message by an independent checker
+ */
+export declare class FactCheck {
+    readonly raw: tl.RawFactCheck;
+    constructor(raw: tl.RawFactCheck);
+    /**
+     * Text of the fact-check
+     */
+    get text(): string;
+    /**
+     * Entities contained in the fact-check text
+     */
+    get entities(): MessageEntity[];
+    /**
+     * Country for which the fact-check is relevant
+     */
+    get country(): string | null;
+    /**
+     * Whether this information might be outdated
+     * and should be re-fetched manually
+     */
+    get shouldRecheck(): boolean;
+    /**
+     * Hash of the fact-check
+     */
+    get hash(): tl.Long;
+}

package/highlevel/types/messages/index.d.cts

@@ -0,0 +1,14 @@
+export * from './dialog.js';
+export * from './draft-message.js';
+export * from './fact-check.js';
+export * from './input-message-id.js';
+export * from './message-action.js';
+export * from './message-effect.js';
+export * from './message-entity.js';
+export * from './message-forward.js';
+export * from './message-media.js';
+export * from './message-reactions.js';
+export * from './message-replies.js';
+export * from './message.js';
+export * from './replied-message.js';
+export * from './search-filters.js';

package/highlevel/types/messages/input-message-id.d.cts

@@ -0,0 +1,20 @@
+import { InputPeerLike } from '../peers/index.js';
+import { Message } from './message.js';
+/**
+ * Parameters for methods that accept a message
+ *
+ * Either a message object (in `message` field), or a chat ID and a message ID
+ */
+export type InputMessageId = {
+    chatId: InputPeerLike;
+    message: number;
+} | {
+    message: Message;
+};
+/** Remove {@link InputMessageId} type from the given type */
+export type OmitInputMessageId<T> = Omit<T, 'chatId' | 'message'>;
+/** @internal */
+export declare function normalizeInputMessageId(id: InputMessageId): {
+    chatId: InputPeerLike;
+    message: number;
+};