@mtcute/core 0.16.7 → 0.16.9

package/highlevel/types/premium/stars-transaction.d.ts

@@ -0,0 +1,120 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { Peer } from '../peers/peer.js';
+import { User } from '../peers/user.js';
+import { MessageMedia } from '../messages/message-media.js';
+import { WebDocument } from '../files/web-document.js';
+/**
+ * Type of the transaction.
+ *
+ *  - `unsupported`: This transaction is not supported by the current version of client
+ *  - `app_store`, `play_market`, `premium_bot`, `fragment`: This transaction is a purchase
+ *    through App Store, Play Market, Premium Bot or Fragment respectively
+ *  - `fragment_withdraw`: This transaction is a withdrawal via Fragment
+ *  - `ads`: This transaction is with the Telegram Ads platform
+ *  - `reaction`: This transaction is a paid reaction in a chat
+ *  - `gift`: This transaction is a gift from a user
+ *  - `bot_purchase`: This transaction is a purchase at a bot-operated store
+ *  - `channel_subscription`: This transaction is a subscription to a channel
+ */
+export type StarsTransactionType = {
+    type: 'unsupported';
+} | {
+    type: 'app_store';
+} | {
+    type: 'play_market';
+} | {
+    type: 'premium_bot';
+} | {
+    type: 'fragment';
+} | {
+    type: 'fragment_withdraw';
+    status: 'pending' | 'success' | 'failed';
+    /** If successful, date of the withdrawal */
+    date?: Date;
+    /** If successful, URL of the withdrawal transaction */
+    url?: string;
+} | {
+    type: 'ads';
+} | {
+    type: 'reaction';
+    /**
+     * Related peer
+     *
+     * - For incoming transactions - user who sent the reaction
+     * - For outgoing transactions - channel which received the reaction
+     */
+    peer: Peer;
+    /** ID of the message containing the reaction */
+    messageId: number;
+} | {
+    type: 'gift';
+    /** User who sent the gift */
+    user: User;
+} | {
+    type: 'media_purchase';
+    /**
+     * Related peer
+     *
+     * - For incoming transactions - user who bought the media
+     * - For outgoing transactions - seller of the media
+     */
+    peer: Peer;
+    /** ID of the message containing the media */
+    messageId: number;
+    /** The bought media (available if not refunded) */
+    media?: MessageMedia[];
+} | {
+    type: 'bot_purchase';
+    /**
+     * Related user
+     *
+     * - For incoming transactions - user who bought the item
+     * - For outgoing transactions - the seller bot
+     */
+    user: User;
+    /** Photo of the item, if available */
+    photo?: WebDocument;
+    /** Title of the item */
+    title: string;
+    /** Description of the item */
+    description?: string;
+    /** Custom payload of the item */
+    payload?: Uint8Array;
+} | {
+    type: 'channel_subscription';
+    /**
+     * Related peer
+     *
+     * - For incoming transactions - user who subscribed to the channel
+     * - For outgoing transactions - channel which was subscribed to
+     */
+    peer: Peer;
+    /** Period of the subscription, in seconds */
+    period: number;
+} | {
+    type: 'giveaway';
+    /** Related peer */
+    peer: Peer;
+    /** ID of the message containing the giveaway where the stars were given */
+    messageId: number;
+};
+export declare class StarsTransaction {
+    readonly raw: tl.RawStarsTransaction;
+    readonly peers: PeersIndex;
+    constructor(raw: tl.RawStarsTransaction, peers: PeersIndex);
+    /** ID of the transaction */
+    get id(): string;
+    /** Whether this transaction is a refund */
+    get isRefund(): boolean;
+    /**
+     * Whether this transaction is outgoing or incoming
+     */
+    get direction(): 'incoming' | 'outgoing';
+    /** Absolute amount of stars in the transaction */
+    get amount(): tl.Long;
+    /** Date of the transaction */
+    get date(): Date;
+    /** Type of this transaction */
+    get type(): StarsTransactionType;
+}

package/highlevel/types/reactions/emoji-status.d.ts

@@ -0,0 +1,12 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Information about user's emoji status
+ */
+export declare class EmojiStatus {
+    readonly raw: Exclude<tl.TypeEmojiStatus, tl.RawEmojiStatusEmpty>;
+    constructor(raw: Exclude<tl.TypeEmojiStatus, tl.RawEmojiStatusEmpty>);
+    /** ID of the custom emoji */
+    get emoji(): tl.Long;
+    /** This status is valid at most until this date */
+    get expireDate(): Date | null;
+}

package/highlevel/types/reactions/peer-reaction.d.ts

@@ -0,0 +1,53 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { User } from '../peers/user.js';
+import { Peer } from '../peers/peer.js';
+import { ReactionEmoji } from './types.js';
+/**
+ * Reactions of a user to a message
+ */
+export declare class PeerReaction {
+    readonly raw: tl.RawMessagePeerReaction;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawMessagePeerReaction, _peers: PeersIndex);
+    /**
+     * Emoji representing the reaction
+     */
+    get emoji(): ReactionEmoji;
+    /**
+     * Whether this is a big reaction
+     */
+    get big(): boolean;
+    /**
+     * Whether this reaction is unread by the current user
+     */
+    get unread(): boolean;
+    /**
+     * ID of the user who has reacted
+     */
+    get userId(): number;
+    /**
+     * User who has reacted
+     */
+    get user(): User;
+}
+/**
+ * Information about paid reactions of a single user to a message,
+ * currently only used for a per-post leaderboard in the app.
+ */
+export declare class PaidPeerReaction {
+    readonly raw: tl.RawMessageReactor;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawMessageReactor, _peers: PeersIndex);
+    /** Whether this reaction is from the current user */
+    get my(): boolean;
+    /** Whether this reaction was sent anonymously */
+    get anonymous(): boolean;
+    /**
+     * If this reaction was not sent anonymously,
+     * this field will contain the user who sent it
+     */
+    get peer(): Peer | null;
+    /** Number of reactions sent by this user */
+    get count(): number;
+}

package/highlevel/types/reactions/reaction-count.d.ts

@@ -0,0 +1,25 @@
+import { tl } from '@mtcute/tl';
+import { ReactionEmoji } from './types.js';
+/**
+ * Reaction count
+ */
+export declare class ReactionCount {
+    readonly raw: tl.RawReactionCount;
+    constructor(raw: tl.RawReactionCount);
+    /**
+     * Emoji representing the reaction
+     */
+    get emoji(): ReactionEmoji;
+    /** Whether this is a paid reaction */
+    get isPaid(): boolean;
+    /**
+     * Number of users who reacted with this emoji
+     */
+    get count(): number;
+    /**
+     * If the current user has reacted with this emoji,
+     * this field will contain the order in which the
+     * reaction was added.
+     */
+    get order(): number | null;
+}

package/highlevel/types/reactions/types.d.ts

@@ -0,0 +1,16 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Input version of {@link ReactionEmoji}, which also accepts bare TL object
+ */
+export type InputReaction = string | tl.Long | tl.TypeReaction;
+/**
+ * Emoji describing a reaction.
+ *
+ * Either a `string` with a unicode emoji, or a `tl.Long` for a custom emoji
+ *
+ * For paid reactions, will always contain `⭐` emoji
+ */
+export type ReactionEmoji = string | tl.Long;
+export declare function normalizeInputReaction(reaction?: InputReaction | null): tl.TypeReaction;
+export declare function toReactionEmoji(reaction: tl.TypeReaction, allowEmpty?: false): ReactionEmoji;
+export declare function toReactionEmoji(reaction: tl.TypeReaction, allowEmpty: true): ReactionEmoji | null;

package/highlevel/types/stories/all-stories.d.ts

@@ -0,0 +1,28 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/index.js';
+import { PeerStories } from './peer-stories.js';
+import { StoriesStealthMode } from './stealth-mode.js';
+/**
+ * All stories of the current user
+ *
+ * Returned by {@link TelegramClient.getAllStories}
+ */
+export declare class AllStories {
+    /** Raw TL object */
+    readonly raw: tl.stories.RawAllStories;
+    /** Peers index */
+    readonly _peers: PeersIndex;
+    constructor(
+    /** Raw TL object */
+    raw: tl.stories.RawAllStories);
+    /** Whether there are more stories to fetch */
+    get hasMore(): boolean;
+    /** Next offset for pagination */
+    get next(): string;
+    /** Total number of {@link PeerStories} available */
+    get total(): number;
+    /** Peers with their stories */
+    get peerStories(): PeerStories[];
+    /** Stealth mode info */
+    get stealthMode(): StoriesStealthMode | null;
+}

package/highlevel/types/stories/interactive/base.d.ts

@@ -0,0 +1,16 @@
+import { tl } from '@mtcute/tl';
+export declare abstract class StoryInteractiveArea {
+    readonly raw: tl.TypeMediaArea;
+    abstract type: string;
+    constructor(raw: tl.TypeMediaArea);
+    /** X coordinate of the top-left corner of the area */
+    get x(): number;
+    /** Y coordinate of the top-left corner of the area */
+    get y(): number;
+    /** Width of the area */
+    get width(): number;
+    /** Height of the area */
+    get height(): number;
+    /** Rotation of the area */
+    get rotation(): number;
+}

package/highlevel/types/stories/interactive/channel-post.d.ts

@@ -0,0 +1,17 @@
+import { tl } from '@mtcute/tl';
+import { Chat } from '../../peers/chat.js';
+import { PeersIndex } from '../../peers/peers-index.js';
+import { StoryInteractiveArea } from './base.js';
+/**
+ * Interactive element containing a channel post
+ */
+export declare class StoryInteractiveChannelPost extends StoryInteractiveArea {
+    readonly raw: tl.RawMediaAreaChannelPost;
+    readonly _peers: PeersIndex;
+    readonly type: "channel_post";
+    constructor(raw: tl.RawMediaAreaChannelPost, _peers: PeersIndex);
+    /** Channel being mentioned */
+    get chat(): Chat;
+    /** ID of the message being mentioned */
+    get messageId(): number;
+}

package/highlevel/types/stories/interactive/index.d.ts

@@ -0,0 +1,12 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../../peers/index.js';
+import { StoryInteractiveChannelPost } from './channel-post.js';
+import { StoryInteractiveLocation } from './location.js';
+import { StoryInteractiveReaction } from './reaction.js';
+import { StoryInteractiveUrl } from './url.js';
+import { StoryInteractiveVenue } from './venue.js';
+import { StoryInteractiveWeather } from './weather.js';
+export * from './input.js';
+export { StoryInteractiveChannelPost, StoryInteractiveLocation, StoryInteractiveReaction, StoryInteractiveUrl, StoryInteractiveVenue, StoryInteractiveWeather, };
+export type StoryInteractiveElement = StoryInteractiveReaction | StoryInteractiveLocation | StoryInteractiveVenue | StoryInteractiveChannelPost | StoryInteractiveUrl | StoryInteractiveWeather;
+export declare function _storyInteractiveElementFromTl(raw: tl.TypeMediaArea, peers: PeersIndex): StoryInteractiveElement;

package/highlevel/types/stories/interactive/input.d.ts

@@ -0,0 +1,68 @@
+import { tl } from '@mtcute/tl';
+import { VenueSource } from '../../media/index.js';
+import { InputReaction } from '../../reactions/index.js';
+/**
+ * Constructor for interactive story elements.
+ *
+ * @example
+ *   ```typescript
+ *      const element = StoryElement
+ *          .at({ x: 0, y: 0, width: 10, height: 10 })
+ *          .reaction('👍', { dark: true })
+ *   ```
+ */
+export declare class StoryElement {
+    private _position;
+    private constructor();
+    static at(params: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        rotation?: number;
+    }): StoryElement;
+    venue(params: {
+        /**
+         * Latitude of the geolocation
+         */
+        latitude: number;
+        /**
+         * Longitude of the geolocation
+         */
+        longitude: number;
+        /**
+         * Venue name
+         */
+        title: string;
+        /**
+         * Venue address
+         */
+        address: string;
+        /**
+         * Source where this venue was acquired
+         */
+        source: VenueSource;
+    }): tl.RawMediaAreaVenue;
+    venueFromInline(queryId: tl.Long, resultId: string): tl.RawInputMediaAreaVenue;
+    location(params: {
+        /**
+         * Latitude of the geolocation
+         */
+        latitude: number;
+        /**
+         * Longitude of the geolocation
+         */
+        longitude: number;
+    }): tl.RawMediaAreaGeoPoint;
+    reaction(reaction: InputReaction, params?: {
+        /**
+         * Whether this reaction is on a dark background
+         */
+        dark?: boolean;
+        /**
+         * Whether this reaction is flipped (i.e. has tail on the left)
+         */
+        flipped?: boolean;
+    }): tl.RawMediaAreaSuggestedReaction;
+    url(url: string): tl.RawMediaAreaUrl;
+}

package/highlevel/types/stories/interactive/location.d.ts

@@ -0,0 +1,15 @@
+import { tl } from '@mtcute/tl';
+import { Location } from '../../media/location.js';
+import { StoryInteractiveArea } from './base.js';
+/**
+ * Interactive element containing a location on the map
+ */
+export declare class StoryInteractiveLocation extends StoryInteractiveArea {
+    readonly raw: tl.RawMediaAreaGeoPoint;
+    readonly type: "location";
+    constructor(raw: tl.RawMediaAreaGeoPoint);
+    /**
+     * Geolocation
+     */
+    get location(): Location;
+}

package/highlevel/types/stories/interactive/reaction.d.ts

@@ -0,0 +1,21 @@
+import { tl } from '@mtcute/tl';
+import { ReactionEmoji } from '../../reactions/index.js';
+import { StoryInteractiveArea } from './base.js';
+/**
+ * Interactive element containing a reaction.
+ *
+ * Number of reactions should be taken from {@link StoryViews} by emoji ID
+ *
+ * For whatever reason, in MTProto dimensions of these are expected to be 16:9
+ */
+export declare class StoryInteractiveReaction extends StoryInteractiveArea {
+    readonly raw: tl.RawMediaAreaSuggestedReaction;
+    readonly type: "reaction";
+    constructor(raw: tl.RawMediaAreaSuggestedReaction);
+    /** Whether this reaction is on a dark background */
+    get isDark(): boolean;
+    /** Whether this reaction is flipped (i.e. has tail on the left) */
+    get isFlipped(): boolean;
+    /** Emoji representing the reaction */
+    get emoji(): ReactionEmoji;
+}

package/highlevel/types/stories/interactive/url.d.ts

@@ -0,0 +1,11 @@
+import { tl } from '@mtcute/tl';
+import { StoryInteractiveArea } from './base.js';
+/**
+ * Interactive element containing a URL link
+ */
+export declare class StoryInteractiveUrl extends StoryInteractiveArea {
+    readonly raw: tl.RawMediaAreaUrl;
+    readonly type: "url";
+    constructor(raw: tl.RawMediaAreaUrl);
+    get url(): string;
+}

package/highlevel/types/stories/interactive/venue.d.ts

@@ -0,0 +1,28 @@
+import { tl } from '@mtcute/tl';
+import { Location } from '../../media/location.js';
+import { VenueSource } from '../../media/venue.js';
+import { StoryInteractiveArea } from './base.js';
+/**
+ * Interactive element containing a venue
+ */
+export declare class StoryInteractiveVenue extends StoryInteractiveArea {
+    readonly raw: tl.RawMediaAreaVenue;
+    readonly type: "venue";
+    constructor(raw: tl.RawMediaAreaVenue);
+    /**
+     * 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;
+}

package/highlevel/types/stories/interactive/weather.d.ts

@@ -0,0 +1,15 @@
+import { tl } from '@mtcute/tl';
+import { StoryInteractiveArea } from './base.js';
+/**
+ * Interactive element containing a weather info
+ */
+export declare class StoryInteractiveWeather extends StoryInteractiveArea {
+    readonly raw: tl.RawMediaAreaWeather;
+    readonly type: "weather";
+    constructor(raw: tl.RawMediaAreaWeather);
+    /** Emoji representing the weather */
+    get emoji(): string;
+    /** Temperature in Celsius */
+    get temperature(): number;
+    get color(): number;
+}

package/highlevel/types/stories/peer-stories.d.ts

@@ -0,0 +1,20 @@
+import { tl } from '@mtcute/tl';
+import { Peer, PeersIndex } from '../peers/index.js';
+import { Story } from './story.js';
+export declare class PeerStories {
+    readonly raw: tl.RawPeerStories;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawPeerStories, _peers: PeersIndex);
+    /**
+     * Peer that owns these stories.
+     */
+    get peer(): Peer;
+    /**
+     * ID of the last read story of this peer.
+     */
+    get maxReadId(): number;
+    /**
+     * List of peer stories.
+     */
+    get stories(): Story[];
+}

package/highlevel/types/stories/stealth-mode.d.ts

@@ -0,0 +1,9 @@
+import { tl } from '@mtcute/tl';
+export declare class StoriesStealthMode {
+    readonly raw: tl.RawStoriesStealthMode;
+    constructor(raw: tl.RawStoriesStealthMode);
+    /** Stealth mode is active until this date */
+    get activeUntil(): Date | null;
+    /** Stealth mode is having a cooldown until this date */
+    get cooldownUntil(): Date | null;
+}

package/highlevel/types/stories/story-interactions.d.ts

@@ -0,0 +1,34 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { User } from '../peers/user.js';
+import { ReactionCount } from '../reactions/reaction-count.js';
+/**
+ * Brief information about story views/interactions
+ */
+export declare class StoryInteractions {
+    readonly raw: tl.RawStoryViews;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawStoryViews, _peers: PeersIndex);
+    /**
+     * Whether information about viewers is available.
+     *
+     * When `true`, you can use {@link TelegarmClient.getStoryViewers}
+     * to get the full list of viewers, and also {@link recentViewers}
+     * will be available.
+     */
+    get hasViewers(): boolean;
+    /** Number of views */
+    get viewsCount(): number;
+    /** Number of forwards (if available) */
+    get forwardsCount(): number | null;
+    /** Total number of reactions */
+    get reactionsCount(): number;
+    /**
+     * Reactions on the message, along with their counts
+     */
+    get reactions(): ReactionCount[];
+    /**
+     * List of users who have recently viewed this story.
+     */
+    get recentViewers(): User[];
+}

package/highlevel/types/stories/story-viewer.d.ts

@@ -0,0 +1,75 @@
+import { tl } from '@mtcute/tl';
+import { Message } from '../messages/index.js';
+import { Peer, PeersIndex, User } from '../peers/index.js';
+import { ReactionEmoji } from '../reactions/index.js';
+import { Story } from './story.js';
+/**
+ * Information about a single user who has viewed a story.
+ */
+export declare class StoryViewer {
+    readonly raw: tl.RawStoryView;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawStoryView, _peers: PeersIndex);
+    /** Whether this user is in current user's global blacklist */
+    get isBlocked(): boolean;
+    /** Whether current user's stories are hidden from this user */
+    get isStoriesBlocked(): boolean;
+    /** Date when the view has occurred */
+    get date(): Date;
+    /** Reaction this user has left, if any */
+    get reactionEmoji(): ReactionEmoji | null;
+    /** Information about the user */
+    get user(): User;
+}
+/**
+ * Kind of a story repost.
+ * - `forward` - a story has been forwarded somewhere
+ * - `repost` - a story has been reposted as a story
+ */
+export type StoryRepostKind = 'forward' | 'repost';
+/**
+ * Information about a single story repost.
+ */
+export declare class StoryRepost {
+    readonly raw: tl.RawStoryViewPublicForward | tl.RawStoryViewPublicRepost;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawStoryViewPublicForward | tl.RawStoryViewPublicRepost, _peers: PeersIndex);
+    /** Whether this peer is in current user's global blacklist */
+    get isBlocked(): boolean;
+    /** Whether current user's stories are hidden from this peer */
+    get isStoriesBlocked(): boolean;
+    /** Kind of the repost */
+    get kind(): StoryRepostKind;
+    /** Date when the repost has happened */
+    get date(): Date;
+    /**
+     * Message that has been forwarded/reposted.
+     *
+     * Only available if {@link kind} is `forward`.
+     */
+    get message(): Message | null;
+    /**
+     * Story that has been reposted.
+     *
+     * Only available if {@link kind} is `repost`.
+     */
+    get story(): Story | null;
+    /** Information about the peer who has made the reposted */
+    get peer(): Peer;
+}
+/**
+ * List of story viewers.
+ */
+export declare class StoryViewersList {
+    readonly raw: tl.stories.RawStoryViewsList;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.stories.RawStoryViewsList);
+    /** Next offset for pagination */
+    get next(): string | undefined;
+    /** Total number of views this story has */
+    get total(): number;
+    /** Total number of reactions this story has */
+    get reactionsTotal(): number;
+    /** List of viewers */
+    get viewers(): StoryViewer[];
+}