@mtcute/core 0.16.6 → 0.16.9

package/highlevel/types/peers/full-chat.d.ts

@@ -0,0 +1,107 @@
+import { tl } from '@mtcute/tl';
+import { Photo } from '../media/photo.js';
+import { StickerSet } from '../misc/sticker-set.js';
+import { BusinessAccount } from '../premium/business-account.js';
+import { Chat } from './chat.js';
+import { ChatInviteLink } from './chat-invite-link.js';
+import { ChatLocation } from './chat-location.js';
+/**
+ * Complete information about a particular chat.
+ */
+export declare class FullChat extends Chat {
+    readonly fullPeer: tl.TypeUserFull | tl.TypeChatFull;
+    constructor(peer: tl.TypeUser | tl.TypeChat, fullPeer: tl.TypeUserFull | tl.TypeChatFull);
+    /** @internal */
+    static _parse(full: tl.messages.RawChatFull | tl.users.TypeUserFull): FullChat;
+    /**
+     * Whether this chat (user) has restricted sending them voice/video messages.
+     */
+    get hasBlockedVoices(): boolean;
+    /** Whether paid reactions are enabled for this channel */
+    get hasPaidReactions(): boolean;
+    /**
+     * Full information about this chat's photo, if any.
+     *
+     * Unlike {@link Chat.photo}, this field contains additional information
+     * about the photo, such as its date, more sizes, and is the only
+     * way to get the animated profile photo.
+     *
+     * This field takes into account any personal/fallback photo
+     * that the user may have set
+     */
+    get fullPhoto(): Photo | null;
+    /**
+     * A custom photo (set by the current user) that should be displayed
+     * instead of the actual chat photo.
+     *
+     * Currently only available for users.
+     */
+    get personalPhoto(): Photo | null;
+    /**
+     * Actual profile photo of the user, bypassing the custom one.
+     */
+    get realPhoto(): Photo | null;
+    /**
+     * A photo that the user has set to be shown
+     * in case their actual profile photo is not available
+     * due to privacy settings.
+     *
+     * Currently only available for users.
+     */
+    get publicPhoto(): Photo | null;
+    /**
+     * Bio of the other party in a private chat, or description of a
+     * group, supergroup or channel.
+     */
+    get bio(): string | null;
+    /**
+     * Chat's primary invite link, for groups, supergroups and channels.
+     */
+    get inviteLink(): ChatInviteLink | null;
+    /**
+     * For supergroups, information about the group sticker set.
+     */
+    get stickerSet(): StickerSet | null;
+    /**
+     * For supergroups, information about the group emoji set.
+     */
+    get emojiSet(): StickerSet | null;
+    /**
+     * Whether the group sticker set can be changed by you.
+     */
+    get canSetStickerSet(): boolean | null;
+    /**
+     * Number of boosts applied by the current user to this chat.
+     */
+    get boostsApplied(): number;
+    /**
+     * Number of boosts required for the user to be unrestricted in this chat.
+     */
+    get boostsForUnrestrict(): number;
+    /** Whether the current user can view Telegram Stars revenue for this chat */
+    get canViewStarsRevenue(): boolean;
+    /**
+     * Chat members count, for groups, supergroups and channels only.
+     */
+    get membersCount(): number | null;
+    /**
+     * Location of the chat.
+     */
+    get location(): ChatLocation | null;
+    private _linkedChat?;
+    /**
+     * Information about a linked chat:
+     * - for channels: the discussion group
+     * - for supergroups: the linked channel
+     * - for users: the personal channel
+     */
+    get linkedChat(): Chat | null;
+    /**
+     * TTL of all messages in this chat, in seconds
+     */
+    get ttlPeriod(): number | null;
+    /**
+     * If this is a business account, information about the business.
+     */
+    get business(): BusinessAccount | null;
+}

package/highlevel/types/peers/peers-index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/highlevel/types/peers/user.d.ts

@@ -0,0 +1,268 @@
+import { tl } from '@mtcute/tl';
+import { MessageEntity } from '../messages/message-entity.js';
+import { EmojiStatus } from '../reactions/emoji-status.js';
+import { ChatColors } from './chat-colors.js';
+import { ChatPhoto } from './chat-photo.js';
+/**
+ * User's Last Seen & Online status.
+ * Can be one of the following:
+ *  - `online`, user is online right now.
+ *  - `offline`, user is currently offline.
+ *  - `recently`, user with hidden last seen time who was online between 1 second and 72 hours ago.
+ *  - `within_week`, user with hidden last seen time who was online between 72 hours and 7 days ago.
+ *  - `within_month`, user with hidden last seen time who was online between 7 days and a month ago.
+ *  - `long_time_ago`, blocked user or user with hidden last seen time who was online more than a month ago.
+ *  - `bot`, for bots.
+ */
+export type UserStatus = 'online' | 'offline' | 'recently' | 'within_week' | 'within_month' | 'long_time_ago' | 'bot';
+export interface UserParsedStatus {
+    status: UserStatus;
+    lastOnline: Date | null;
+    nextOffline: Date | null;
+    byMe: boolean;
+}
+export declare class User {
+    readonly type: "user";
+    /**
+     * Underlying raw TL object
+     */
+    readonly raw: tl.RawUser;
+    constructor(user: tl.TypeUser);
+    /** Unique identifier for this user or bot */
+    get id(): number;
+    /**
+     * Whether this user's information is incomplete.
+     *
+     * This usually only happens in large chats, where
+     * the server sometimes sends only a part of the user's
+     * information. Basic info like name and profile photo
+     * are always available, but other fields may be omitted
+     * despite being available.
+     *
+     * It was observed that these fields may be missing:
+     *   - `username, usernames`
+     *   - `status, lastOnline, nextOffline`
+     *   - `storiesMaxId`
+     *   - `photo` - in some cases when user has some some privacy settings
+     *   - and probably more
+     *
+     * This currently only ever happens for non-bot users, so if you are building
+     * a normal bot, you can safely ignore this field.
+     *
+     * To fetch the "complete" user information, use one of these methods:
+     *  - {@link TelegramClient.getUsers}
+     *  - {@link TelegramClient.getChat}
+     *  - {@link TelegramClient.getFullChat}.
+     *
+     * Learn more: [Incomplete peers](https://mtcute.dev/guide/topics/peers.html#incomplete-peers)
+     */
+    get isMin(): boolean;
+    /** Whether this user is you yourself */
+    get isSelf(): boolean;
+    /** Whether this user is in your contacts */
+    get isContact(): boolean;
+    /** Whether you both have each other's contact */
+    get isMutualContact(): boolean;
+    /** Whether this user is in yout "close friends" list */
+    get isCloseFriend(): boolean;
+    /** Whether this user is deleted */
+    get isDeleted(): boolean;
+    /** Whether this user is a bot */
+    get isBot(): boolean;
+    /**
+     * Whether this user is a bot that can be connected to a
+     * Telegram Business account to receive its messages
+     */
+    get isBusinessBot(): boolean;
+    /** Whether this user is a bot that has access to all messages */
+    get isBotWithHistory(): boolean;
+    /** Whether this user is a bot that can't be added to chats */
+    get isBotWithoutChats(): boolean;
+    /** Whether this bot offers an attachment menu web app */
+    get isBotWithAttachmentMenu(): boolean;
+    /** Whether this bot can be edited by the current user */
+    get isBotEditable(): boolean;
+    /** Whether this user has been verified by Telegram */
+    get isVerified(): boolean;
+    /**
+     * Whether this user has been restricted. Bots only.
+     * See {@link restrictionReason} for details
+     */
+    get isRestricted(): boolean;
+    /**
+     * Reason why this bot was restricted
+     */
+    get restrictionReason(): tl.TypeRestrictionReason[];
+    /** Whether this user has been flagged for scam */
+    get isScam(): boolean;
+    /** Whether this user has been flagged for impersonation */
+    get isFake(): boolean;
+    /** Whether this user is part of the Telegram support team */
+    get isSupport(): boolean;
+    /** Whether this user has Premium subscription */
+    get isPremium(): boolean;
+    /** Whether Premium is required to contact this user */
+    get isPremiumRequired(): boolean;
+    /** Number of bot's active users, if available */
+    get botActiveUsers(): number | null;
+    /** Whether this bot has a main app */
+    get hasMainApp(): boolean;
+    /** User's or bot's first name */
+    get firstName(): string;
+    /** User's or bot's last name */
+    get lastName(): string | null;
+    static parseStatus(status?: tl.TypeUserStatus, bot?: boolean): UserParsedStatus;
+    private get _parsedStatus();
+    /** User's Last Seen & Online status */
+    get status(): UserStatus;
+    /**
+     * Whether user's online status is hidden because
+     * we have hidden our own online status from them,
+     * and we don't have Premium subscription.
+     */
+    get statusHiddenByMe(): boolean;
+    /**
+     * Last time this user was seen online.
+     * Only available if {@link status} is `offline`
+     */
+    get lastOnline(): Date | null;
+    /**
+     * Time when this user will automatically go offline.
+     * Only available if {@link status} is `online`
+     */
+    get nextOffline(): Date | null;
+    /** User's or bot's username */
+    get username(): string | null;
+    /** User's or bot's usernames (including collectibles) */
+    get usernames(): ReadonlyArray<tl.RawUsername> | null;
+    /**
+     * IETF language tag of the user's language
+     *
+     * Only available in some contexts
+     */
+    get language(): string | null;
+    /**
+     * User's or bot's assigned DC (data center).
+     * Available only in case the user has set a public profile photo.
+     *
+     * **Note**: this information is approximate; it is based on where
+     * Telegram stores a user profile pictures and does not by any means tell
+     * you the user location (i.e. a user might travel far away, but will still connect
+     * to its assigned DC).
+     * More info at [Pyrogram FAQ](https://docs.pyrogram.org/faq#what-are-the-ip-addresses-of-telegram-data-centers).
+     */
+    get dcId(): number | null;
+    /** User's phone number */
+    get phoneNumber(): string | null;
+    /**
+     * Get this user's input peer for advanced use-cases.
+     *
+     * > **Note**: for {@link min} users, this method will return
+     * > `mtcute.dummyInputPeerMinUser`, which is actually not a valid input peer.
+     * > These are used to indicate that the user is incomplete, and a message
+     * > reference is needed to resolve the peer.
+     * >
+     * > Such objects are handled by {@link TelegramClient.resolvePeer} method,
+     * > so prefer using it whenever you need an input peer.
+     */
+    get inputPeer(): tl.TypeInputPeer;
+    /**
+     * User's or bot's current profile photo, if any.
+     * Suitable for downloads only
+     */
+    get photo(): ChatPhoto | null;
+    /**
+     * The list of reasons why this bot might be unavailable to some users.
+     * This field is available only in case *isRestricted* is `true`
+     */
+    get restrictions(): ReadonlyArray<tl.RawRestrictionReason> | null;
+    /**
+     * User's display name.
+     *
+     * First name and last name if available,
+     * only first name otherwise.
+     */
+    get displayName(): string;
+    /**
+     * User's emoji status, if any.
+     */
+    get emojiStatus(): EmojiStatus | null;
+    /** Whether you have hidden (arhived) this user's stories */
+    get storiesHidden(): boolean;
+    get storiesUnavailable(): boolean;
+    /**
+     * Maximum ID of stories this user has (or 0 if none)
+     */
+    get storiesMaxId(): number;
+    /**
+     * Color that should be used when rendering replies to
+     * their messages and web previews sent by them,
+     * as well as to render the chat title
+     */
+    get color(): ChatColors;
+    /**
+     * Color that should be used when rendering the header of
+     * the user's profile
+     *
+     * If `null`, a generic header should be used instead
+     */
+    get profileColors(): ChatColors | null;
+    /**
+     * Create a mention for the user.
+     *
+     * When available and `text` is omitted, this method will return `@username`.
+     * Otherwise, text mention is created.
+     *
+     * Use `null` as `text` (first parameter) to force create a text
+     * mention with display name, even if there is a username.
+     *
+     * > **Note**: This method doesn't format anything on its own.
+     * > Instead, it returns a {@link MessageEntity} that can later
+     * > be used with `html` or `md` template tags
+     *
+     * @param text  Text of the mention.
+     * @example
+     * ```typescript
+     * msg.replyText(html`Hello, ${msg.sender.mention()`)
+     * ```
+     */
+    mention(text?: string | null): string | MessageEntity;
+    /**
+     * Create a permanent mention for this user.
+     *
+     * Permanent* means that this mention will also
+     * contain user's access hash, so even if the user
+     * changes their username or the client forgets
+     * about that user, it can still be mentioned.
+     *
+     * Telegram might change access hash in some cases,
+     * so it may not exactly be *permanent*. The only way
+     * to actually make it permanent is to send it as a message
+     * somewhere and load it from there if needed.
+     *
+     * Note that some users (particularly, users with hidden forwards)
+     * may not be mentioned like this outside the chats you have in common.
+     *
+     * This method is only needed when the result will be
+     * stored somewhere outside current mtcute instance (e.g. saved for later use),
+     * otherwise {@link mention} will be enough.
+     *
+     * > **Note**: This method doesn't format anything on its own.
+     * > Instead, it returns a {@link MessageEntity} that can later
+     * > be used with `html` or `md` template tags
+     *
+     * > **Note**: the resulting text can only be used by clients
+     * > that support mtcute notation of permanent
+     * > mention links (`tg://user?id=123&hash=abc`).
+     * >
+     * > Also note that these permanent mentions are only
+     * > valid for current account, since peer access hashes are
+     * > account-specific and can't be used on another account.
+     * >
+     * > Also note that for some users such mentions might not work at all
+     * > due to privacy settings.
+     *
+     * @param text  Mention text
+     */
+    permanentMention(text?: string | null): MessageEntity;
+}

package/highlevel/types/peers/user.test.d.ts

@@ -0,0 +1 @@
+export {};

package/highlevel/types/premium/boost-slot.d.ts

@@ -0,0 +1,37 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex, Chat } from '../peers/index.js';
+/**
+ * Information about a boost slot
+ */
+export declare class BoostSlot {
+    readonly raw: tl.RawMyBoost;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawMyBoost, _peers: PeersIndex);
+    /** ID of this slot */
+    get id(): number;
+    /**
+     * Whether this slot is occupied
+     */
+    get occupied(): boolean;
+    /**
+     * Channel that is occupying this slot, if any
+     */
+    get chat(): Chat | null;
+    /**
+     * Date when we started boosting this channel
+     *
+     * If this slot is not occupied, will be `0`
+     */
+    get date(): Date;
+    /**
+     * Date when this boost will automatically expire.
+     */
+    get expireDate(): Date;
+    /**
+     * If this slot is occupied, returns the date when
+     * we can reassing this slot to another channel.
+     *
+     * If `null`, we can reassign it immediately.
+     */
+    get cooldownUntil(): Date | null;
+}

package/highlevel/types/premium/boost.d.ts

@@ -0,0 +1,57 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex, User } from '../peers/index.js';
+/**
+ * Origin of a boost
+ *
+ * - `gift` - boost applied because the channel gifted a subscription to some user
+ * - `unclaimed_gift` - boost applied because the channel gifted a subscription to some user,
+ *   but the user hasn't yet claimed it
+ * - `giveaway` - boost applied because the user was chosen in a giveaway
+ * - `user` - boost applied because the user directly boosted the channel
+ */
+type BoostOrigin = 'gift' | 'unclaimed_gift' | 'giveaway' | 'user';
+/**
+ * Information about a boost (one or more)
+ */
+export declare class Boost {
+    readonly raw: tl.RawBoost;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawBoost, _peers: PeersIndex);
+    /** Unique ID of this boost */
+    get id(): string;
+    /** Number of boosts this boost is actually representing */
+    get count(): number;
+    /** Date when this boost was applied */
+    get date(): Date;
+    /** Amount of Telegram Stars that were awarded along with this boost */
+    get stars(): tl.Long | null;
+    /**
+     * Date when this boost will automatically expire.
+     *
+     * > **Note**: User can still manually cancel the boost before that date
+     */
+    get expireDate(): Date;
+    /**
+     * Whether this boost was applied because the channel
+     * directly gifted a subscription to the user
+     */
+    get origin(): BoostOrigin;
+    /**
+     * User who is boosting the channel.
+     *
+     * Only available for some origins
+     */
+    get user(): User | null;
+    /**
+     * ID of the message containing the giveaway where this
+     * user has won
+     */
+    get giveawayMessageId(): number | null;
+    /**
+     * The created Telegram Premium gift code, only set if `origin` is not `user`,
+     * AND it is either a gift code for the currently logged in user,
+     * or if it was already claimed
+     */
+    get usedGiftSlug(): string | null;
+}
+export {};

package/highlevel/types/premium/business-work-hours.test.d.ts

@@ -0,0 +1 @@
+export {};

package/highlevel/types/premium/index.d.ts

@@ -0,0 +1,10 @@
+export * from './boost.js';
+export * from './boost-slot.js';
+export * from './boost-stats.js';
+export * from './business-account.js';
+export * from './business-chat-link.js';
+export * from './business-connection.js';
+export * from './business-intro.js';
+export * from './business-work-hours.js';
+export * from './stars-transaction.js';
+export * from './stars-status.js';

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

@@ -0,0 +1,16 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { StarsTransaction } from './stars-transaction.js';
+export declare class StarsStatus {
+    readonly raw: tl.payments.RawStarsStatus;
+    readonly peers: PeersIndex;
+    constructor(raw: tl.payments.RawStarsStatus);
+    /** Current Telegram Stars balance */
+    get balance(): tl.Long;
+    /**
+     * History of Telegram Stars transactions
+     */
+    get transactions(): StarsTransaction[];
+    /** Next offset of {@link transactions} for pagination */
+    get transactionsNextOffset(): string | null;
+}

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/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;
+}