@mtcute/core 0.18.0-rc.5 → 0.18.0

package/highlevel/types/media/paid-media.d.cts

@@ -0,0 +1,33 @@
+import { tl } from '@mtcute/tl';
+import { MessageMedia } from '../messages/message-media.js';
+import { ExtendedMediaPreview } from './extended-media.js';
+export declare class PaidMedia {
+    readonly raw: tl.RawMessageMediaPaidMedia;
+    private readonly _extendedMedia;
+    readonly type: "paid";
+    constructor(raw: tl.RawMessageMediaPaidMedia, _extendedMedia: MessageMedia[]);
+    /** Whether this media was paid for */
+    get isPaid(): boolean;
+    /** Price of the media (in Telegram Stars) */
+    get price(): tl.Long;
+    /**
+     * Get the available media previews.
+     *
+     * If the media is already paid for, this will return an empty array.
+     */
+    get previews(): ExtendedMediaPreview[];
+    /**
+     * Get the available full media.
+     *
+     * If the media is not paid for, this will return an empty array.
+     */
+    get medias(): MessageMedia[];
+    /**
+     * Input media TL object generated from this object,
+     * to be used inside {@link InputMediaLike} and
+     * {@link TelegramClient.sendMedia}.
+     *
+     * Will throw if the media is not paid for.
+     */
+    get inputMedia(): tl.TypeInputMedia;
+}

package/highlevel/types/media/photo.d.cts

@@ -0,0 +1,72 @@
+import { tl } from '@mtcute/tl';
+import { FileLocation } from '../files/index.js';
+import { Thumbnail } from './thumbnail.js';
+/**
+ * A photo
+ */
+export declare class Photo extends FileLocation {
+    readonly raw: tl.RawPhoto;
+    readonly media?: tl.RawMessageMediaPhoto | undefined;
+    readonly type: "photo";
+    /** Biggest available photo width */
+    readonly width: number;
+    /** Biggest available photo height */
+    readonly height: number;
+    private _bestSize?;
+    constructor(raw: tl.RawPhoto, media?: tl.RawMessageMediaPhoto | undefined);
+    /**
+     * Photo ID
+     */
+    get id(): tl.Long;
+    /** Date this photo was sent */
+    get date(): Date;
+    /**
+     * Whether this photo is an animated profile picture
+     */
+    get isAnimatedAvatar(): boolean;
+    /**
+     * Whether this photo is an animated profile picture, built from an emoji/sticker markup
+     */
+    get isMarkupAvatar(): boolean;
+    /** Whether this photo is hidden with a spoiler */
+    get hasSpoiler(): boolean;
+    /** For self-destructing photos, TTL in seconds */
+    get ttlSeconds(): number | null;
+    /**
+     * Available thumbnails.
+     *
+     * **Note**: This list will also contain the largest thumbnail that is
+     * represented by the current object.
+     */
+    get thumbnails(): ReadonlyArray<Thumbnail>;
+    /**
+     * Get a photo thumbnail by its type.
+     *
+     * Thumbnail types are described in the
+     * [Telegram docs](https://core.telegram.org/api/files#image-thumbnail-types),
+     * and are also available as static members of {@link Thumbnail} for convenience.
+     *
+     * @param type  Thumbnail type
+     */
+    getThumbnail(type: string): Thumbnail | null;
+    /**
+     * Get TDLib and Bot API compatible File ID
+     * representing this photo's best thumbnail.
+     */
+    get fileId(): string;
+    /**
+     * Get TDLib and Bot API compatible Unique File ID
+     * representing this photo's best thumbnail.
+     */
+    get uniqueFileId(): string;
+    /**
+     * Input photo generated from this object.
+     */
+    get inputPhoto(): tl.TypeInputPhoto;
+    /**
+     * Input media generated from this object,
+     * to be used in {@link InputMediaLike} and
+     * {@link TelegramClient.sendMedia}
+     */
+    get inputMedia(): tl.TypeInputMedia;
+}

package/highlevel/types/media/poll.d.cts

@@ -0,0 +1,110 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { MessageEntity } from '../messages/message-entity.js';
+export declare class PollAnswer {
+    readonly raw: tl.TypePollAnswer;
+    readonly result?: tl.RawPollAnswerVoters | undefined;
+    constructor(raw: tl.TypePollAnswer, result?: tl.RawPollAnswerVoters | undefined);
+    /**
+     * Answer text
+     */
+    get text(): string;
+    /**
+     * Format entities for {@link text}, currently may only contain custom emojis
+     */
+    get textEntities(): ReadonlyArray<MessageEntity>;
+    /**
+     * Answer data, to be passed to
+     * {@link TelegramClient.sendVote}
+     */
+    get data(): Uint8Array;
+    /**
+     * Number of people who has chosen this result.
+     * If not available (i.e. not voted yet)
+     *
+     * @default
+     */
+    get voters(): number;
+    /**
+     * Whether this answer was chosen by the current user
+     */
+    get chosen(): boolean;
+    /**
+     * Whether this answer is correct (for quizzes).
+     * Not available before choosing an answer
+     *
+     * @default
+     */
+    get correct(): boolean;
+}
+export declare class Poll {
+    readonly raw: tl.TypePoll;
+    readonly _peers: PeersIndex;
+    readonly results?: tl.RawPollResults | undefined;
+    readonly type: "poll";
+    constructor(raw: tl.TypePoll, _peers: PeersIndex, results?: tl.RawPollResults | undefined);
+    /**
+     * Unique identifier of the poll
+     */
+    get id(): tl.Long;
+    /**
+     * Poll question
+     */
+    get question(): string;
+    /**
+     * Format entities for {@link question} (currently may only contain custom emojis)
+     */
+    get questionEntities(): ReadonlyArray<MessageEntity>;
+    /**
+     * List of answers in this poll
+     */
+    get answers(): ReadonlyArray<PollAnswer>;
+    /**
+     * Total number of voters in this poll, if available
+     */
+    get voters(): number;
+    /**
+     * Whether this poll is closed, i.e. does not
+     * accept votes anymore
+     */
+    get isClosed(): boolean;
+    /**
+     * Whether this poll is public, i.e. you
+     * list of voters is publicly available
+     */
+    get isPublic(): boolean;
+    /**
+     * Whether this is a quiz
+     */
+    get isQuiz(): boolean;
+    /**
+     * Whether this poll accepts multiple answers
+     */
+    get isMultiple(): boolean;
+    /**
+     * Solution for the quiz, only available
+     * in case you have already answered
+     */
+    get solution(): string | null;
+    /**
+     * Format entities for {@link solution}, only available
+     * in case you have already answered
+     */
+    get solutionEntities(): ReadonlyArray<MessageEntity> | null;
+    /**
+     * Input media TL object generated from this object,
+     * to be used inside {@link InputMediaLike} and
+     * {@link TelegramClient.sendMedia}
+     *
+     * A few notes:
+     *  - Using this will result in an
+     *    independent poll, which will not
+     *    be auto-updated with the current.
+     *  - If this is a quiz, a normal poll
+     *    will be returned since the client does not
+     *    know the correct answer.
+     *  - This always returns a non-closed poll,
+     *    even if the current poll was closed
+     */
+    get inputMedia(): tl.TypeInputMedia;
+}

package/highlevel/types/media/sticker.d.cts

@@ -0,0 +1,123 @@
+import { tl } from '@mtcute/tl';
+import { tdFileId } from '@mtcute/file-id';
+import { RawDocument } from './document.js';
+export declare const MASK_POSITION_POINT_TO_TL: {
+    readonly forehead: 0;
+    readonly eyes: 1;
+    readonly mouth: 2;
+    readonly chin: 3;
+};
+export interface MaskPosition {
+    /**
+     * The part of the face relative where the mask should be placed
+     */
+    point: 'forehead' | 'eyes' | 'mouth' | 'chin';
+    /**
+     * Shift by X-axis measured in widths of the mask scaled to
+     * the face size, from left to right. For example, choosing
+     * -1.0 will place mask just to the left of the default
+     * mask position.
+     */
+    x: number;
+    /**
+     * Shift by Y-axis measured in heights of the mask scaled to
+     * the face size, from top to bottom. For example, 1.0
+     * will place the mask just below the default mask position.
+     */
+    y: number;
+    /**
+     * Mask scaling coefficient. For example, 2.0 means double size.
+     */
+    scale: number;
+}
+/**
+ * Type of the sticker
+ * - `sticker`: regular sticker
+ * - `mask`: mask sticker
+ * - `emoji`: custom emoji
+ */
+export type StickerType = 'sticker' | 'mask' | 'emoji';
+/**
+ * Sticker source file type
+ * - `static`: static sticker (webp)
+ * - `animated`: animated sticker (gzipped lottie json)
+ * - `video`: video sticker (webm)
+ */
+export type StickerSourceType = 'static' | 'animated' | 'video';
+/**
+ * A sticker
+ */
+export declare class Sticker extends RawDocument {
+    readonly attr: tl.RawDocumentAttributeSticker | tl.RawDocumentAttributeCustomEmoji;
+    readonly attr2?: tl.RawDocumentAttributeImageSize | tl.RawDocumentAttributeVideo | undefined;
+    readonly type: "sticker";
+    protected _fileIdType(): tdFileId.FileType;
+    constructor(doc: tl.RawDocument, attr: tl.RawDocumentAttributeSticker | tl.RawDocumentAttributeCustomEmoji, attr2?: tl.RawDocumentAttributeImageSize | tl.RawDocumentAttributeVideo | undefined);
+    /**
+     * Sticker width in pixels
+     */
+    get width(): number;
+    /**
+     * Sticker height in pixels
+     */
+    get height(): number;
+    /**
+     * Whether this sticker is a premium sticker
+     * (has premium fullscreen animation)
+     */
+    get isPremiumSticker(): boolean;
+    /**
+     * Whether this sticker is a valid sticker.
+     *
+     * If it is not, then this is probably a WEBP photo
+     * that Telegram treats as a sticker.
+     */
+    get isValidSticker(): boolean;
+    /**
+     * Primary emoji associated with this sticker,
+     * that is displayed in dialogs list.
+     *
+     * If there is none, empty string is returned.
+     *
+     * **Note:** This only contains at most one emoji.
+     * Some stickers have multiple associated emojis,
+     * but only one is returned here. This is Telegram's
+     * limitation! Use {@link getAllEmojis} instead.
+     *
+     * For custom emojis, this alt should be used as a fallback
+     * text that will be "behind" the custom emoji entity.
+     */
+    get emoji(): string;
+    /**
+     * Whether this custom emoji can be used by non-premium users.
+     * `false` if this is not a custom emoji.
+     *
+     * > Not sure if there are any such stickers currently.
+     */
+    get customEmojiFree(): boolean;
+    /**
+     * If this is a custom emoji, its unique ID
+     * that can be used in {@link TelegramClient#getCustomEmojis}
+     */
+    get customEmojiId(): tl.Long;
+    /**
+     * Type of the sticker
+     */
+    get stickerType(): StickerType;
+    /**
+     * Type of the file representing the sticker
+     */
+    get sourceType(): StickerSourceType;
+    /**
+     * Whether this sticker has an associated public sticker set.
+     */
+    get hasStickerSet(): boolean;
+    /**
+     * Input sticker set that it associated with this sticker, if available.
+     */
+    get inputStickerSet(): tl.TypeInputStickerSet | null;
+    /**
+     * Position where this mask should be placed
+     */
+    get maskPosition(): MaskPosition | null;
+}

package/highlevel/types/media/story.d.cts

@@ -0,0 +1,33 @@
+import { tl } from '@mtcute/tl';
+import { Peer } from '../peers/peer.js';
+import { PeersIndex } from '../peers/peers-index.js';
+import { Story } from '../stories/story.js';
+/**
+ * Information about a "forwarded" story in a message,
+ * internally represented as a message media
+ */
+export declare class MediaStory {
+    readonly raw: tl.RawMessageMediaStory;
+    readonly _peers: PeersIndex;
+    readonly type: "story";
+    constructor(raw: tl.RawMessageMediaStory, _peers: PeersIndex);
+    /**
+     * Whether this story was automatically forwarded to you
+     * because you were mentioned in it
+     */
+    get isMention(): boolean;
+    /**
+     * Peer who has posted this story
+     */
+    get peer(): Peer;
+    /**
+     * ID of the story
+     */
+    get storyId(): number;
+    /**
+     * Contents of the story. May not be available, in which case the story
+     * should be fetched using {@link getStoriesById}
+     */
+    get story(): Story | null;
+    get inputMedia(): tl.TypeInputMedia;
+}

package/highlevel/types/media/thumbnail.d.cts

@@ -0,0 +1,70 @@
+import { tl } from '@mtcute/tl';
+import { FileLocation } from '../files/index.js';
+/**
+ * One size of some thumbnail
+ */
+export declare class Thumbnail extends FileLocation {
+    static readonly THUMB_100x100_BOX = "s";
+    static readonly THUMB_320x320_BOX = "m";
+    static readonly THUMB_800x800_BOX = "x";
+    static readonly THUMB_1280x1280_BOX = "y";
+    static readonly THUMB_2560x2560_BOX = "w";
+    static readonly THUMB_160x160_CROP = "a";
+    static readonly THUMB_320x320_CROP = "b";
+    static readonly THUMB_640x640_CROP = "c";
+    static readonly THUMB_1280x1280_CROP = "d";
+    static readonly THUMB_STRIP = "i";
+    static readonly THUMB_OUTLINE = "j";
+    /** Animated profile pictures preview */
+    static readonly THUMB_VIDEO_PROFILE = "u";
+    /** Trimmed and downscaled video previews */
+    static readonly THUMB_VIDEO_PREVIEW = "v";
+    /** Fullscreen animation for Premium stickers */
+    static readonly THUMB_VIDEO_FULLSCREEN = "f";
+    /** (non-standard) Emoji-based markup for profile photo */
+    static readonly THUMB_EMOJI_MARKUP = "pfp_em";
+    /** (non-standard) Sticker-based markup for profile photo */
+    static readonly THUMB_STICKER_MARKUP = "pfp_st";
+    readonly raw: tl.TypePhotoSize | tl.TypeVideoSize;
+    /**
+     * Thumbnail width
+     * (`NaN` for {@link THUMB_OUTLINE} and {@link THUMB_STRIP})
+     */
+    readonly width: number;
+    /**
+     * Thumbnail height
+     * (`NaN` for {@link THUMB_OUTLINE} and {@link THUMB_STRIP})
+     */
+    readonly height: number;
+    private _path?;
+    private _media;
+    constructor(media: tl.RawPhoto | tl.RawDocument | tl.RawStickerSet | tl.RawMessageExtendedMediaPreview, sz: tl.TypePhotoSize | tl.TypeVideoSize);
+    get isVideo(): boolean;
+    /**
+     * Thumbnail type
+     */
+    get type(): string;
+    /**
+     * If {@link raw} is `tl.RawPhotoPathSize` (i.e. `raw.type === Thumbnail.THUMB_OUTLINE`),
+     * this property will return raw SVG path of the preview.
+     *
+     * When downloading path thumbnails, a valid SVG file is returned.
+     *
+     * See also: https://core.telegram.org/api/files#vector-thumbnails
+     *
+     * @throws MtTypeAssertionError  In case {@link raw} is not `tl.RawPhotoPathSize`
+     */
+    get path(): string;
+    /**
+     * Get TDLib and Bot API compatible File ID
+     * representing this thumbnail.
+     *
+     * > **Note:** You can't use this file id to send a thumbnail,
+     * > only to download it.
+     */
+    get fileId(): string;
+    /**
+     * Get a unique File ID representing this thumbnail.
+     */
+    get uniqueFileId(): string;
+}

package/highlevel/types/media/venue.d.cts

@@ -0,0 +1,58 @@
+import { tl } from '@mtcute/tl';
+import { Location } from './location.js';
+export interface VenueSource {
+    /**
+     * Provider name (`foursquare` or `gplaces` for Google Places)
+     */
+    provider?: 'foursquare' | 'gplaces';
+    /**
+     * Venue ID in the provider's DB
+     */
+    id: string;
+    /**
+     * Venue type in the provider's DB
+     *
+     * - [Supported types for Foursquare](https://developer.foursquare.com/docs/build-with-foursquare/categories/)
+     *   (use names, lowercase them, replace spaces and " & " with `_` (underscore) and remove other symbols,
+     *   and use `/` (slash) as hierarchy separator)
+     * - [Supported types for Google Places](https://developers.google.com/places/web-service/supported_types)
+     */
+    type: string;
+}
+export declare class Venue {
+    readonly raw: tl.RawMessageMediaVenue;
+    readonly type: "venue";
+    constructor(raw: tl.RawMessageMediaVenue);
+    /**
+     * Geolocation of the venue
+     */
+    get location(): Location;
+    /**
+     * Venue name
+     */
+    get title(): string;
+    /**
+     * Venue address
+     */
+    get address(): string;
+    /**
+     * When available, source from where this venue was acquired
+     */
+    get source(): VenueSource | null;
+    /**
+     * Input media TL object generated from this object,
+     * to be used inside {@link InputMediaLike} and
+     * {@link TelegramClient.sendMedia}
+     *
+     * A few notes:
+     *  - Using this will result in an
+     *    independent poll, which will not
+     *    be auto-updated with the current.
+     *  - If this is a quiz, a normal poll
+     *    will be returned since the client does not
+     *    know the correct answer.
+     *  - This always returns a non-closed poll,
+     *    even if the current poll was closed
+     */
+    get inputMedia(): tl.TypeInputMedia;
+}

package/highlevel/types/media/video.d.cts

@@ -0,0 +1,48 @@
+import { tl } from '@mtcute/tl';
+import { tdFileId } from '@mtcute/file-id';
+import { RawDocument } from './document.js';
+/**
+ * A video, round video message or GIF animation.
+ *
+ * **Note:** Legacy GIF animations are also wrapped with this class.
+ */
+export declare class Video extends RawDocument {
+    readonly attr: tl.RawDocumentAttributeVideo | tl.RawDocumentAttributeImageSize;
+    readonly media?: tl.RawMessageMediaDocument | undefined;
+    readonly type: "video";
+    protected _fileIdType(): tdFileId.FileType;
+    constructor(doc: tl.RawDocument, attr: tl.RawDocumentAttributeVideo | tl.RawDocumentAttributeImageSize, media?: tl.RawMessageMediaDocument | undefined);
+    /**
+     * Video width in pixels
+     */
+    get width(): number;
+    /**
+     * Video height in pixels
+     */
+    get height(): number;
+    /**
+     * Video duration in seconds.
+     *
+     * `0` for legacy GIFs
+     */
+    get duration(): number;
+    /**
+     * Whether this video is an animated GIF
+     * (represented either by actual GIF or a silent MP4 video)
+     */
+    get isAnimation(): boolean;
+    /**
+     * Whether this video is a round video message (aka video note)
+     */
+    get isRound(): boolean;
+    /**
+     * Whether this video is a legacy GIF (i.e. its MIME is `image/gif`)
+     */
+    get isLegacyGif(): boolean;
+    /** Whether this video is hidden with a spoiler */
+    get hasSpoiler(): boolean;
+    /** For self-destructing videos, TTL in seconds */
+    get ttlSeconds(): number | null;
+    get videoStartTs(): number | null;
+    get codec(): string | null;
+}

package/highlevel/types/media/voice.d.cts

@@ -0,0 +1,23 @@
+import { tl } from '@mtcute/tl';
+import { tdFileId } from '@mtcute/file-id';
+import { RawDocument } from './document.js';
+/**
+ * An voice note.
+ */
+export declare class Voice extends RawDocument {
+    readonly attr: tl.RawDocumentAttributeAudio;
+    readonly type: "voice";
+    protected _fileIdType(): tdFileId.FileType;
+    constructor(doc: tl.RawDocument, attr: tl.RawDocumentAttributeAudio);
+    /**
+     * Duration of the voice note in seconds.
+     */
+    get duration(): number;
+    /**
+     * Voice note's waveform
+     *
+     * Represented with integers in range [0, 31],
+     * usually has length of 100
+     */
+    get waveform(): number[];
+}