@mtcute/core 0.18.0-rc.5 → 0.18.0

package/highlevel/types/peers/chat-event/index.d.cts

@@ -0,0 +1,27 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers-index.js';
+import { ChatAction } from './actions.js';
+import { User } from '../user.js';
+export * from './actions.js';
+export type { ChatEventFilters, InputChatEventFilters } from './filters.js';
+export declare class ChatEvent {
+    readonly raw: tl.TypeChannelAdminLogEvent;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.TypeChannelAdminLogEvent, _peers: PeersIndex);
+    /**
+     * Event ID.
+     *
+     * Event IDs are generated in direct chronological order
+     * (i.e. newer events have bigger event ID)
+     */
+    get id(): tl.Long;
+    /**
+     * Date of the event
+     */
+    get date(): Date;
+    /**
+     * Actor of the event
+     */
+    get actor(): User;
+    get action(): ChatAction;
+}

package/highlevel/types/peers/chat-invite-link-member.d.cts

@@ -0,0 +1,33 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from './peers-index.js';
+import { User } from './user.js';
+export declare class ChatInviteLinkMember {
+    readonly raw: tl.RawChatInviteImporter;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawChatInviteImporter, _peers: PeersIndex);
+    /**
+     * User who joined the chat
+     */
+    get user(): User;
+    /**
+     * Date when the user joined the chat
+     */
+    get date(): Date;
+    /**
+     * Whether this user currently has a pending join request
+     * (and is actually not a member yet)
+     */
+    get isPendingRequest(): boolean;
+    /**
+     * Whether the participant joined by importing a chat folder deep link
+     */
+    get isViaChatlist(): boolean;
+    /**
+     * For users with pending requests, contains bio of the user that requested to join
+     */
+    get bio(): string | null;
+    /**
+     * The administrator that approved the join request of the user
+     */
+    get approvedBy(): User | null;
+}

package/highlevel/types/peers/chat-invite-link.d.cts

@@ -0,0 +1,72 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from './index.js';
+import { User } from './user.js';
+/**
+ * An invite link
+ */
+export declare class ChatInviteLink {
+    readonly _peers?: PeersIndex | undefined;
+    readonly raw: tl.RawChatInviteExported;
+    constructor(raw: tl.TypeExportedChatInvite, _peers?: PeersIndex | undefined);
+    /**
+     * The invite link as a `t.me/joinchat/` string.
+     *
+     * If the link was created by another administrator, the second
+     * part of the link will be censored with `...` (e.g. `https://t.me/joinchat/BGxxHIg4...`
+     *
+     * See also: {@link isMyLink}
+     */
+    get link(): string;
+    /**
+     * Whether this invite link was created by the current user.
+     *
+     * If so, {@link link} will be a full invite link.
+     */
+    get isMyLink(): boolean;
+    /**
+     * Creator of the invite link, if available
+     */
+    get creator(): User | null;
+    /**
+     * Creation date of the link
+     */
+    get date(): Date;
+    /**
+     * Whether this link is primary (i.e. "permanent")
+     */
+    get isPrimary(): boolean;
+    /**
+     * Whether this link was revoked and can't be used anymore
+     */
+    get isRevoked(): boolean;
+    /**
+     * The date since which the link will be valid (if any)
+     */
+    get startDate(): Date | null;
+    /**
+     * The date until which the link will be valid (if any)
+     */
+    get endDate(): Date | null;
+    /**
+     * Maximum number of users that can be members of this chat
+     * at the same time after joining using this link.
+     *
+     * Integer in range `[1, 99999]` or `Infinity` if unspecified
+     */
+    get usageLimit(): number;
+    /**
+     * Number of users currently in the chat that joined using this link
+     */
+    get usage(): number;
+    /**
+     * Whether users joined by this link need to be
+     * approved by the group administrator before they can join
+     */
+    get approvalNeeded(): boolean;
+    /**
+     * Number of users currently awaiting admin approval.
+     *
+     * 0 in case the link is not using approvals
+     */
+    get pendingApprovals(): number;
+}

package/highlevel/types/peers/chat-location.d.cts

@@ -0,0 +1,17 @@
+import { tl } from '@mtcute/tl';
+import { Location } from '../media/location.js';
+/**
+ * Geolocation of a supergroup
+ */
+export declare class ChatLocation {
+    readonly raw: tl.RawChannelLocation;
+    constructor(raw: tl.RawChannelLocation);
+    /**
+     * Location of the chat
+     */
+    get location(): Location;
+    /**
+     * Textual description of the address
+     */
+    get address(): string;
+}

package/highlevel/types/peers/chat-member.d.cts

@@ -0,0 +1,86 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from './index.js';
+import { ChatPermissions } from './chat-permissions.js';
+import { User } from './user.js';
+/**
+ * Status of the member:
+ *  - `creator`: user is the creator of the chat
+ *  - `admin`: user has admin rights in the chat
+ *  - `member`: user is a normal member of the chat
+ *  - `restricted`: user has some restrictions applied
+ *  - `banned`: user was banned from the chat
+ *  - `left`: user left the chat on their own
+ */
+export type ChatMemberStatus = 'creator' | 'admin' | 'member' | 'restricted' | 'banned' | 'left';
+/**
+ * Information about one chat member
+ */
+export declare class ChatMember {
+    readonly raw: tl.TypeChatParticipant | tl.TypeChannelParticipant;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.TypeChatParticipant | tl.TypeChannelParticipant, _peers: PeersIndex);
+    /**
+     * Information about the user
+     */
+    get user(): User;
+    /**
+     * Get the chat member status
+     */
+    get status(): ChatMemberStatus;
+    /**
+     * Custom title (for creators and admins).
+     *
+     * `null` for non-admins and in case custom title is not set.
+     */
+    get title(): string | null;
+    /**
+     * Date when the user has joined the chat.
+     *
+     * Not available for creators and left members
+     */
+    get joinedDate(): Date | null;
+    /**
+     * Information about whoever invited this member to the chat.
+     *
+     * Only available in the following cases:
+     *  - `user` is yourself
+     *  - `chat` is a legacy group
+     *  - `chat` is a supergroup/channel, and `user` is an admin
+     */
+    get invitedBy(): User | null;
+    /**
+     * Information about whoever promoted this admin.
+     *
+     * Only available if `status = admin`.
+     */
+    get promotedBy(): User | null;
+    /**
+     * Information about whoever restricted this user.
+     *
+     * Only available if `status = restricted or status = banned`
+     */
+    get restrictedBy(): User | null;
+    /**
+     * For restricted and banned users,
+     * information about the restrictions
+     */
+    get restrictions(): ChatPermissions | null;
+    /**
+     * Whether this member is a part of the chat now.
+     *
+     * Makes sense only when `status = restricted or staus = banned`
+     */
+    get isMember(): boolean;
+    /**
+     * For admins and creator of supergroup/channels,
+     * list of their admin permissions.
+     *
+     * Also contains whether this admin is anonymous.
+     */
+    get permissions(): tl.RawChatAdminRights | null;
+    /**
+     * If this member subscribed to a channel using Telegram Stars,
+     * this field will contain the date when the subscription will expire
+     */
+    get subscriptionUntilDate(): Date | null;
+}

package/highlevel/types/peers/chat-permissions.d.cts

@@ -0,0 +1,127 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Represents the permissions of a user in a {@link Chat}.
+ */
+export declare class ChatPermissions {
+    readonly raw: tl.RawChatBannedRights;
+    constructor(bannedRights: tl.RawChatBannedRights);
+    /**
+     * Whether users can view messages
+     */
+    get canViewMessages(): boolean;
+    /**
+     * Whether users can send text messages,
+     * contacts, locations and venues
+     */
+    get canSendMessages(): boolean;
+    /**
+     * Whether users can send media messages,
+     * including documents, photos, videos, video notes and voice notes.
+     *
+     * Implies {@link canSendMessages}
+     */
+    get canSendMedia(): boolean;
+    /**
+     * Whether users can send stickers.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canSendStickers(): boolean;
+    /**
+     * Whether users can send GIFs.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canSendGifs(): boolean;
+    /**
+     * Whether users can send photos.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canSendPhotos(): boolean;
+    /**
+     * Whether users can send videos.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canSendVideos(): boolean;
+    /**
+     * Whether users can send round videos (i.e. video notes).
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canSendRoundVideos(): boolean;
+    /**
+     * Whether users can send audio files.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canSendAudios(): boolean;
+    /**
+     * Whether users can send voice notes.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canSendVoices(): boolean;
+    /**
+     * Whether users can send files.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canSendFiles(): boolean;
+    /**
+     * Whether users can send games.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canSendGames(): boolean;
+    /**
+     * Whether users can use inline bots.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canUseInline(): boolean;
+    /**
+     * Whether users can use inline bots.
+     *
+     * Implies {@link canSendMedia}
+     */
+    get canAddWebPreviews(): boolean;
+    /**
+     * Whether users can send text messages.
+     *
+     * Implies {@link canSendMessages}
+     */
+    get canSendText(): boolean;
+    /**
+     * Whether users can send polls.
+     *
+     * Implies {@link canSendMessages}
+     */
+    get canSendPolls(): boolean;
+    /**
+     * Whether users can change the chat title,
+     * photo and other settings.
+     */
+    get canChangeInfo(): boolean;
+    /**
+     * Whether users can invite other users to the chat
+     */
+    get canInviteUsers(): boolean;
+    /**
+     * Whether users can pin messages
+     */
+    get canPinMessages(): boolean;
+    /**
+     * Whether users can pin messages
+     */
+    get canManageTopics(): boolean;
+    /**
+     * UNIX date until which these permissions are valid,
+     * or `null` if forever.
+     *
+     * For example, represents the time when the restrictions
+     * will be lifted from a {@link ChatMember}
+     */
+    get untilDate(): Date | null;
+}

package/highlevel/types/peers/chat-photo.d.cts

@@ -0,0 +1,39 @@
+import { tl } from '@mtcute/tl';
+import { FileLocation } from '../files/index.js';
+/**
+ * A size of a chat photo
+ */
+export declare class ChatPhotoSize extends FileLocation {
+    readonly peer: tl.TypeInputPeer;
+    readonly obj: tl.RawUserProfilePhoto | tl.RawChatPhoto;
+    readonly big: boolean;
+    constructor(peer: tl.TypeInputPeer, obj: tl.RawUserProfilePhoto | tl.RawChatPhoto, big: boolean);
+    /**
+     * TDLib and Bot API compatible File ID representing this size
+     */
+    get fileId(): string;
+    /**
+     * TDLib and Bot API compatible unique File ID representing this size
+     */
+    get uniqueFileId(): string;
+}
+/**
+ * A chat photo
+ */
+export declare class ChatPhoto {
+    readonly peer: tl.TypeInputPeer;
+    readonly raw: tl.RawUserProfilePhoto | tl.RawChatPhoto;
+    constructor(peer: tl.TypeInputPeer, raw: tl.RawUserProfilePhoto | tl.RawChatPhoto);
+    /**
+     * Whether this photo is personal (i.e. you set it yourself for this peer)
+     */
+    get isPersonal(): boolean;
+    /** Chat photo file location in small resolution (160x160) */
+    get small(): ChatPhotoSize;
+    /** Chat photo file location in big resolution (640x640) */
+    get big(): ChatPhotoSize;
+    /**
+     * Chat photo preview in *very* small resolution, if available
+     */
+    get thumb(): Uint8Array | null;
+}

package/highlevel/types/peers/chat-preview.d.cts

@@ -0,0 +1,55 @@
+import { tl } from '@mtcute/tl';
+import { Photo } from '../media/photo.js';
+import { User } from './user.js';
+/**
+ * Chat type. Can be:
+ *  - `group`: Legacy group
+ *  - `supergroup`: Supergroup
+ *  - `channel`: Broadcast channel
+ */
+export type ChatPreviewType = 'group' | 'supergroup' | 'channel';
+export declare class ChatPreview {
+    readonly invite: tl.RawChatInvite;
+    /**
+     * Original invite link used to fetch this preview
+     */
+    readonly link: string;
+    constructor(invite: tl.RawChatInvite, 
+    /**
+     * Original invite link used to fetch this preview
+     */
+    link: string);
+    /**
+     * Title of the chat
+     */
+    get title(): string;
+    /**
+     * Type of the chat
+     */
+    get type(): ChatPreviewType;
+    /**
+     * Whether this chat is public
+     */
+    get public(): boolean;
+    /**
+     * Total chat member count
+     */
+    get memberCount(): number;
+    /**
+     * Chat photo
+     */
+    get photo(): Photo | null;
+    /**
+     * Preview of some of the chat members.
+     *
+     * This usually contains around 10 members,
+     * and members that are inside your contacts list are
+     * ordered before others.
+     */
+    get someMembers(): ReadonlyArray<User>;
+    /**
+     * Whether by using this link you'll also need
+     * to wait for admin approval.
+     */
+    get withApproval(): boolean;
+}