@mtcute/core 0.18.0-rc.5 → 0.18.0

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

@@ -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.cts

@@ -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.cts

@@ -0,0 +1,28 @@
+import { tl } from '@mtcute/tl';
+import { VenueSource } from '../../media/venue.js';
+import { Location } from '../../media/location.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.cts

@@ -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.cts

@@ -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.cts

@@ -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.cts

@@ -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.cts

@@ -0,0 +1,75 @@
+import { tl } from '@mtcute/tl';
+import { Peer, PeersIndex, User } from '../peers/index.js';
+import { ReactionEmoji } from '../reactions/index.js';
+import { Message } from '../messages/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[];
+}

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

@@ -0,0 +1,79 @@
+import { tl } from '@mtcute/tl';
+import { Video } from '../media/video.js';
+import { PeersIndex } from '../peers/index.js';
+import { ReactionEmoji } from '../reactions/index.js';
+import { StoryInteractiveElement } from './interactive/index.js';
+import { Photo } from '../media/photo.js';
+import { MessageEntity } from '../messages/message-entity.js';
+import { StoryInteractions } from './story-interactions.js';
+/**
+ * Information about story visibility.
+ *
+ * - `public` - story is visible to everyone
+ * - `contacts` - story is visible only to contacts
+ * - `selectedContacts` - story is visible only to some contacts
+ * - `closeFriends` - story is visible only to "close friends"
+ */
+export type StoryVisibility = 'public' | 'contacts' | 'selected_contacts' | 'close_friends';
+export type StoryMedia = Photo | Video;
+export declare class Story {
+    readonly raw: tl.RawStoryItem;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawStoryItem, _peers: PeersIndex);
+    /** Whether this story is pinned */
+    get isPinned(): boolean;
+    /**
+     * Whether this object contains reduced set of fields.
+     *
+     * When `true`, these field will not contain correct data:
+     * {@link privacyRules}, {@link interactiveAreas}
+     *
+     */
+    get isShort(): boolean;
+    /** Whether this story is content-protected, i.e. can't be forwarded */
+    get isContentProtected(): boolean;
+    /** Whether this story has been edited */
+    get isEdited(): boolean;
+    /** Whether this story has been posted by the current user */
+    get isMy(): boolean;
+    /** ID of the story */
+    get id(): number;
+    /** Date when this story was posted */
+    get date(): Date;
+    /** Date when this story will expire */
+    get expireDate(): Date;
+    /** Whether the story is active (i.e. not expired yet) */
+    get isActive(): boolean;
+    /** Story visibility */
+    get visibility(): StoryVisibility;
+    /** Caption of the story */
+    get caption(): string | null;
+    /**
+     * Caption entities (may be empty)
+     */
+    get entities(): ReadonlyArray<MessageEntity>;
+    /**
+     * Story media.
+     *
+     * Currently, can only be {@link Photo} or {@link Video}.
+     */
+    get media(): StoryMedia;
+    /**
+     * Interactive elements of the story
+     */
+    get interactiveElements(): StoryInteractiveElement[];
+    /**
+     * Privacy rules of the story.
+     *
+     * Only available when {@link isMy} is `true`.
+     */
+    get privacyRules(): tl.TypePrivacyRule[] | null;
+    /**
+     * Information about story interactions
+     */
+    get interactions(): StoryInteractions | null;
+    /**
+     * Emoji representing a reaction sent by the current user, if any
+     */
+    get sentReactionEmoji(): ReactionEmoji | null;
+}

package/highlevel/types/updates/bot-chat-join-request.d.cts

@@ -0,0 +1,42 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex, Chat, ChatInviteLink, User } from '../peers/index.js';
+/**
+ * This update is sent when a user requests to join a chat
+ * via invite link with approvals.
+ *
+ * > **NOTE**: This update is only received by bots,
+ * > if you are using a user-bot, see {@link ChatJoinRequestUpdate}
+ */
+export declare class BotChatJoinRequestUpdate {
+    readonly raw: tl.RawUpdateBotChatInviteRequester;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateBotChatInviteRequester, _peers: PeersIndex);
+    /**
+     * Chat ID where the user is requesting to join.
+     */
+    get chatId(): number;
+    /**
+     * Object containing the chat information.
+     */
+    get chat(): Chat;
+    /**
+     * ID of the user who requested to join the chat.
+     */
+    get userId(): number;
+    /**
+     * Object containing the user information.
+     */
+    get user(): User;
+    /**
+     * Bio of the user who requested to join the chat.
+     */
+    get userBio(): string;
+    /**
+     * Date when the request was sent.
+     */
+    get date(): Date;
+    /**
+     * Invite link used to request joining.
+     */
+    get invite(): ChatInviteLink;
+}

package/highlevel/types/updates/bot-reaction.d.cts

@@ -0,0 +1,71 @@
+import { tl } from '@mtcute/tl';
+import { Peer } from '../peers/peer.js';
+import { PeersIndex } from '../peers/peers-index.js';
+import { InputReaction } from '../reactions/types.js';
+import { ReactionCount } from '../reactions/reaction-count.js';
+/**
+ * A reaction to a message was changed by a user.
+ *
+ * These updates are only received for bots - for PMs and in chats
+ * where the bot is an administrator.
+ *
+ * Reactions sent by other bots are not received.
+ */
+export declare class BotReactionUpdate {
+    readonly raw: tl.RawUpdateBotMessageReaction;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateBotMessageReaction, _peers: PeersIndex);
+    /**
+     * Chat where the reaction has been changed
+     */
+    get chat(): Peer;
+    /**
+     * ID of the message where the reaction has been changed
+     */
+    get messageId(): number;
+    /**
+     * Date when the reaction has been changed
+     */
+    get date(): Date;
+    /**
+     * ID of the user who has set/removed the reaction
+     */
+    get actor(): Peer;
+    /**
+     * List of reactions before the change
+     */
+    get before(): InputReaction[];
+    /**
+     * List of reactions after the change
+     */
+    get after(): InputReaction[];
+}
+/**
+ * The count of reactions to a message has been updated.
+ *
+ * These updates are only received for bots in chats where
+ * the bot is an administrator. Unlike {@link BotReactionUpdate},
+ * this update is used for chats where the list of users who
+ * reacted to a message is not visible (e.g. channels).
+ */
+export declare class BotReactionCountUpdate {
+    readonly raw: tl.RawUpdateBotMessageReactions;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateBotMessageReactions, _peers: PeersIndex);
+    /**
+     * Chat where the reaction has been changed
+     */
+    get chat(): Peer;
+    /**
+     * ID of the message where the reaction has been changed
+     */
+    get messageId(): number;
+    /**
+     * Date when the reaction has been changed
+     */
+    get date(): Date;
+    /**
+     * The new list of reactions to the message
+     */
+    get reactions(): ReactionCount[];
+}

package/highlevel/types/updates/bot-stopped.d.cts

@@ -0,0 +1,28 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex, User } from '../peers/index.js';
+/**
+ * A user has stopped or restarted the bot.
+ *
+ * This update is **not** sent the first time user
+ * interacts with the bot.
+ */
+export declare class BotStoppedUpdate {
+    readonly raw: tl.RawUpdateBotStopped;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateBotStopped, _peers: PeersIndex);
+    /**
+     * ID of the user who stopped or restarted the bot
+     */
+    get userId(): number;
+    /**
+     * User who stopped or restarted the bot
+     */
+    get user(): User;
+    /**
+     * Whether the bot is currently stopped.
+     *
+     * If `true`, then the user has stopped the bot.
+     * If `false`, then the user has re-started the bot.
+     */
+    get stopped(): boolean;
+}

package/highlevel/types/updates/business-message.d.cts

@@ -0,0 +1,18 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { Message } from '../messages/message.js';
+/**
+ * Update about a new or edited business message.
+ */
+export declare class BusinessMessage extends Message {
+    readonly update: tl.RawUpdateBotNewBusinessMessage | tl.RawUpdateBotEditBusinessMessage;
+    readonly _peers: PeersIndex;
+    constructor(update: tl.RawUpdateBotNewBusinessMessage | tl.RawUpdateBotEditBusinessMessage, _peers: PeersIndex);
+    /**
+     * Unique identifier of the business connection from which the message was received.
+     */
+    get connectionId(): string;
+    get groupedIdUnique(): string | null;
+    /** The replied message (if any) */
+    get replyTo(): Message | null;
+}

package/highlevel/types/updates/callback-query.d.cts

@@ -0,0 +1,95 @@
+import { tl } from '@mtcute/tl';
+import { Peer } from '../peers/peer.js';
+import { PeersIndex } from '../peers/peers-index.js';
+import { Message } from '../messages/message.js';
+import { User } from '../peers/user.js';
+/** Base class for callback queries */
+declare class BaseCallbackQuery {
+    readonly raw: tl.RawUpdateBotCallbackQuery | tl.RawUpdateInlineBotCallbackQuery | tl.RawUpdateBusinessBotCallbackQuery;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateBotCallbackQuery | tl.RawUpdateInlineBotCallbackQuery | tl.RawUpdateBusinessBotCallbackQuery, _peers: PeersIndex);
+    /**
+     * ID of this callback query
+     */
+    get id(): tl.Long;
+    /**
+     * User who has pressed the button
+     */
+    get user(): User;
+    /**
+     * Unique ID, that represents the chat to which the inline
+     * message was sent. Does *not* contain actual chat ID.
+     */
+    get uniqueChatId(): tl.Long;
+    /**
+     * Data that was contained in the callback button, if any
+     *
+     * Note that this field is defined by the client, and a bad
+     * client can send arbitrary data in this field.
+     */
+    get data(): Uint8Array | null;
+    /**
+     * Data that was contained in the callback button, if any,
+     * parsed as a UTF8 string
+     *
+     * Note that this field is defined by the client, and a bad
+     * client can send arbitrary data in this field.
+     */
+    get dataStr(): string | null;
+    /**
+     * In case this message was from {@link InputInlineResultGame},
+     * or the button was {@link BotKeyboard.game},
+     * short name of the game that should be returned.
+     */
+    get game(): string | null;
+}
+/**
+ * A callback query originating from a normal message sent by the bot.
+ */
+export declare class CallbackQuery extends BaseCallbackQuery {
+    readonly raw: tl.RawUpdateBotCallbackQuery;
+    constructor(raw: tl.RawUpdateBotCallbackQuery, _peers: PeersIndex);
+    /**
+     * Chat where the originating message was sent
+     */
+    get chat(): Peer;
+    /**
+     * Identifier of the message containing the button which was clicked.
+     */
+    get messageId(): number;
+}
+/**
+ * A callback query originating from an inline message sent by the bot.
+ */
+export declare class InlineCallbackQuery extends BaseCallbackQuery {
+    readonly raw: tl.RawUpdateInlineBotCallbackQuery;
+    constructor(raw: tl.RawUpdateInlineBotCallbackQuery, _peers: PeersIndex);
+    /**
+     * Identifier of the previously sent inline message,
+     * that contained the button which was clicked.
+     * This ID can be used in `TelegramClient.editInlineMessage`
+     */
+    get inlineMessageId(): tl.TypeInputBotInlineMessageID;
+    /**
+     * Identifier of the previously sent inline message,
+     * that contained the button which was clicked,
+     * as a TDLib and Bot API compatible string.
+     * Can be used instead of {@link inlineMessageId} in
+     * case you want to store it in some storage.
+     */
+    get inlineMessageIdStr(): string;
+}
+/**
+ * A callback query originating from a message sent by the bot via a business connection
+ */
+export declare class BusinessCallbackQuery extends BaseCallbackQuery {
+    readonly raw: tl.RawUpdateBusinessBotCallbackQuery;
+    constructor(raw: tl.RawUpdateBusinessBotCallbackQuery, _peers: PeersIndex);
+    /** ID of the business connection */
+    get connectionId(): string;
+    /** Message containing the button */
+    get message(): Message;
+    /** Message that {@link message} is a reply to (if any) */
+    get replyToMessage(): Message | null;
+}
+export {};

package/highlevel/types/updates/chat-join-request.d.cts

@@ -0,0 +1,30 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex, User } from '../peers/index.js';
+/**
+ * This update is sent when a user requests to join a chat
+ * via invite link with approvals.
+ *
+ * > **NOTE**: This update is only received by users,
+ * > if you are using a bot, see {@link BotChatJoinRequestUpdate}
+ */
+export declare class ChatJoinRequestUpdate {
+    readonly raw: tl.RawUpdatePendingJoinRequests;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdatePendingJoinRequests, _peers: PeersIndex);
+    /**
+     * Marked ID of the chat/channel
+     */
+    get chatId(): number;
+    /**
+     * IDs of the users who recently requested to join the chat
+     */
+    get recentRequestersIds(): number[];
+    /**
+     * Users who recently requested to join the chat
+     */
+    get recentRequesters(): User[];
+    /**
+     * Total number of pending requests
+     */
+    get totalPending(): number;
+}

package/highlevel/types/updates/chat-member-update.cjs

@@ -57,6 +57,7 @@ class ChatMemberUpdate {
     const curId = extractPeerId(cur);
     const actorId = this.raw.actorId;
     if (!old && cur) {
+      if (cur._ === "channelParticipantBanned") return "kicked";
       return actorId === curId ? "joined" : "added";
     }
     if (old && !cur) {

package/highlevel/types/updates/chat-member-update.d.cts

@@ -0,0 +1,76 @@
+import { PeersIndex } from '../peers/peers-index.js';
+import { tl } from '@mtcute/tl';
+import { ChatInviteLink } from '../peers/chat-invite-link.js';
+import { ChatMember } from '../peers/chat-member.js';
+import { Chat } from '../peers/chat.js';
+import { User } from '../peers/user.js';
+/**
+ * Type of the event. Can be one of:
+ *  - `joined`: User `user` joined the chat/channel on their own
+ *  - `added`: User `actor` added another user `user` to the chat
+ *  - `left`: User `user` left the channel on their own
+ *  - `kicked`: User `user` was kicked from the chat by `actor`
+ *  - `unkicked`: User `user` was removed from the list of kicked users by `actor` and can join the chat again
+ *  - `restricted`: User `user` was restricted by `actor`
+ *  - `unrestricted`: User `user` was unrestricted by `actor`
+ *  - `unrestricted_promoted`: User `user` was unrestricted AND promoted to an admin by `actor`
+ *  - `promoted`: User `user` was promoted to admin by `actor`
+ *  - `demoted`: User `user` was demoted from admin by `actor`
+ *  - `demoted_restricted`: User `user` was demoted from admin AND restricted by `actor`
+ *  - `demoted_kicked`: User `user` was demoted from admin AND kicked by `actor`
+ *  - `old_owner`: User `user` transferred their own chat ownership
+ *  - `new_owner`: User `actor` transferred their chat ownership to `user`
+ *  - `other`: Some other event (e.g. change in restrictions, change in admin rights, etc.)
+ */
+export type ChatMemberUpdateType = 'joined' | 'added' | 'left' | 'kicked' | 'unkicked' | 'restricted' | 'unrestricted' | 'unrestricted_promoted' | 'promoted' | 'demoted' | 'demoted_restricted' | 'demoted_kicked' | 'old_owner' | 'new_owner' | 'other';
+/**
+ * Update representing a change in the status
+ * of a chat/channel member.
+ */
+export declare class ChatMemberUpdate {
+    readonly raw: tl.RawUpdateChatParticipant | tl.RawUpdateChannelParticipant;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateChatParticipant | tl.RawUpdateChannelParticipant, _peers: PeersIndex);
+    /**
+     * Date of the event
+     */
+    get date(): Date;
+    /**
+     * Whether this is an update about current user
+     */
+    get isSelf(): boolean;
+    /**
+     * Type of the update
+     *
+     * @link ChatMemberUpdate.Type
+     */
+    get type(): ChatMemberUpdateType;
+    /**
+     * Chat in which this event has occurred
+     */
+    get chat(): Chat;
+    /**
+     * Performer of the action which resulted in this update.
+     *
+     * Can be chat/channel administrator or the {@link user} themself.
+     */
+    get actor(): User;
+    /**
+     * User representing the chat member whose status was changed.
+     */
+    get user(): User;
+    /** Whether this is a self-made action (i.e. actor == user) */
+    get isSelfMade(): boolean;
+    /**
+     * Previous (old) information about chat member.
+     */
+    get oldMember(): ChatMember | null;
+    /**
+     * Current (new) information about chat member.
+     */
+    get newMember(): ChatMember | null;
+    /**
+     * In case this is a "join" event, invite link that was used to join (if any)
+     */
+    get inviteLink(): ChatInviteLink | null;
+}