@mtcute/core 0.18.0-rc.5 → 0.19.0

package/highlevel/types/misc/collectible-info.d.cts

@@ -0,0 +1,27 @@
+import { tl } from '@mtcute/tl';
+import { default as Long } from 'long';
+/**
+ * Information about a Fragment collectible
+ */
+export declare class CollectibleInfo {
+    readonly raw: tl.fragment.RawCollectibleInfo;
+    constructor(raw: tl.fragment.RawCollectibleInfo);
+    /** Date when the item was purchased */
+    get purchaseDate(): Date;
+    /** Crypto currency used to purchase the item */
+    get cryptoCurrency(): string;
+    /**
+     * Amount of crypto currency used to purchase the item,
+     * in the smallest units
+     */
+    get cryptoAmount(): Long;
+    /** Fiat currency to which the crypto currency was converted */
+    get currency(): string;
+    /**
+     * Converted amount in fiat currency,
+     * in the smallest units (e.g. cents)
+     */
+    get amount(): Long;
+    /** URL to the collectible on Fragment */
+    get url(): string;
+}

package/highlevel/types/misc/entities.d.cts

@@ -0,0 +1,22 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Formatted text with entities
+ */
+export interface TextWithEntities {
+    readonly text: string;
+    readonly entities?: tl.TypeMessageEntity[];
+}
+/**
+ * Type to be used as a parameter for methods that accept
+ * a formatted text with entities.
+ *
+ * Can be either a plain string or an object with `text` and `entities` fields.
+ */
+export type InputText = string | TextWithEntities;
+/**
+ * Convert {@link InputText} to a {@link tl.RawTextWithEntities} object
+ *
+ * @param text  Input text
+ * @returns  TL object
+ */
+export declare function inputTextToTl(text: InputText): tl.RawTextWithEntities;

package/highlevel/types/misc/index.d.cts

@@ -0,0 +1,6 @@
+export * from './app-config.js';
+export * from './collectible-info.js';
+export * from './entities.js';
+export * from './input-privacy-rule/index.js';
+export * from './sticker-set.js';
+export * from './takeout-session.js';

package/highlevel/types/misc/input-privacy-rule/allow.d.cts

@@ -0,0 +1,22 @@
+import { tl } from '@mtcute/tl';
+import { MaybeArray } from '../../../../types/utils.js';
+import { InputPeerLike } from '../../peers/peer.js';
+import { InputPrivacyRuleChatParticipants, InputPrivacyRuleUsers } from './types.js';
+/** Allow all users */
+export declare const all: tl.RawInputPrivacyValueAllowAll;
+/** Allow only contacts */
+export declare const contacts: tl.RawInputPrivacyValueAllowContacts;
+/** Allow only "close friends" list */
+export declare const closeFriends: tl.RawInputPrivacyValueAllowCloseFriends;
+/**
+ * Allow only users specified in `users`
+ *
+ * @param users  Users to allow
+ */
+export declare function users(users: MaybeArray<InputPeerLike>): InputPrivacyRuleUsers;
+/**
+ * Allow only participants of chats specified in `chats`
+ *
+ * @param chats  Chats to allow
+ */
+export declare function chatParticipants(chats: MaybeArray<InputPeerLike>): InputPrivacyRuleChatParticipants;

package/highlevel/types/misc/input-privacy-rule/bundle.d.cts

@@ -0,0 +1,3 @@
+import * as allow from './allow.js';
+import * as disallow from './disallow.js';
+export { allow, disallow };

package/highlevel/types/misc/input-privacy-rule/disallow.d.cts

@@ -0,0 +1,20 @@
+import { tl } from '@mtcute/tl';
+import { MaybeArray } from '../../../../types/utils.js';
+import { InputPeerLike } from '../../peers/peer.js';
+import { InputPrivacyRuleChatParticipants, InputPrivacyRuleUsers } from './types.js';
+/** Disallow all users */
+export declare const all: tl.RawInputPrivacyValueDisallowAll;
+/** Disallow contacts */
+export declare const contacts: tl.RawInputPrivacyValueDisallowContacts;
+/**
+ * Disallow users specified in `users`
+ *
+ * @param users  Users to disallow
+ */
+export declare function users(users: MaybeArray<InputPeerLike>): InputPrivacyRuleUsers;
+/**
+ * Disallow participants of chats specified in `chats`
+ *
+ * @param chats  Chats to disallow
+ */
+export declare function chatParticipants(chats: MaybeArray<InputPeerLike>): InputPrivacyRuleChatParticipants;

package/highlevel/types/misc/input-privacy-rule/index.d.cts

@@ -0,0 +1,3 @@
+import * as PrivacyRule from './bundle.js';
+export { PrivacyRule };
+export * from './types.js';

package/highlevel/types/misc/input-privacy-rule/types.d.cts

@@ -0,0 +1,11 @@
+import { tl } from '@mtcute/tl';
+import { InputPeerLike } from '../../peers/peer.js';
+export interface InputPrivacyRuleUsers {
+    allow: boolean;
+    users: InputPeerLike[];
+}
+export interface InputPrivacyRuleChatParticipants {
+    allow: boolean;
+    chats: InputPeerLike[];
+}
+export type InputPrivacyRule = InputPrivacyRuleChatParticipants | InputPrivacyRuleUsers | tl.TypeInputPrivacyRule;

package/highlevel/types/misc/sticker-set.d.cts

@@ -0,0 +1,154 @@
+import { InputFileLike } from '../files/index.js';
+import { MaskPosition, Sticker, StickerType, Thumbnail } from '../media/index.js';
+import { tl } from '@mtcute/tl';
+/**
+ * Input sticker set.
+ * Can be one of:
+ *   - Raw TL object
+ *   - Sticker set short name
+ *   - {@link StickerSet} object
+ *   - `{ dice: "<emoji>" }` (e.g. `{ dice: "🎲" }`) - Used for fetching animated dice stickers
+ *   - `{ system: string }` - for system stickersets:
+ *      - `"animated"` - Animated emojis stickerset
+ *      - `"animated_animations"` - Animated emoji reaction stickerset
+ *         (contains animations to play when a user clicks on a given animated emoji)
+ *      - `"premium_gifts"` - Stickers to show when receiving a gifted Telegram Premium subscription,
+ *      - `"generic_animations"` - Generic animation stickerset containing animations to play
+ *         when reacting to messages using a normal emoji without a custom animation
+ *      - `"default_statuses"` - Default custom emoji status stickerset
+ *      - `"default_topic_icons"` - Default custom emoji stickerset for forum topic icons
+ *      - `"default_channel_statuses"` - Default custom emoji status stickerset for channels
+ */
+export type InputStickerSet = tl.TypeInputStickerSet | {
+    dice: string;
+} | {
+    system: 'animated' | 'animated_animations' | 'premium_gifts' | 'generic_animations' | 'default_statuses' | 'default_topic_icons' | 'default_channel_statuses';
+} | StickerSet | string;
+export declare function normalizeInputStickerSet(input: InputStickerSet): tl.TypeInputStickerSet;
+/**
+ * Information about one sticker inside the set
+ */
+export interface StickerInfo {
+    /**
+     * Primary alt emoji that is displayed in dialogs list
+     */
+    readonly alt: string;
+    /**
+     * One or more emojis representing this sticker
+     */
+    readonly emoji: string;
+    /**
+     * Document with the actual sticker
+     */
+    readonly sticker: Sticker;
+}
+/**
+ * A sticker set (aka sticker pack)
+ */
+export declare class StickerSet {
+    readonly brief: tl.RawStickerSet;
+    readonly full?: tl.messages.RawStickerSet;
+    readonly cover?: tl.TypeStickerSetCovered;
+    /**
+     * Whether this object contains information about stickers inside the set
+     */
+    readonly isFull: boolean;
+    constructor(raw: tl.TypeStickerSet | tl.messages.TypeStickerSet | tl.TypeStickerSetCovered);
+    /**
+     * Whether this sticker set was archived
+     * (due to too many saved stickers in the current account)
+     */
+    get isArchived(): boolean;
+    /**
+     * Whether this stickerset is official
+     */
+    get isOfficial(): boolean;
+    /**
+     * Whether this sticker set was created by the current user
+     */
+    get isCreator(): boolean;
+    /**
+     * Type of the stickers in this set
+     */
+    get type(): StickerType;
+    /**
+     * Date when this sticker set was installed
+     */
+    get installedDate(): Date | null;
+    /**
+     * Number of stickers in this sticker set
+     */
+    get count(): number;
+    /**
+     * Input sticker set to be used in other API methods
+     */
+    get inputStickerSet(): tl.TypeInputStickerSet;
+    /**
+     * Title of the sticker set
+     */
+    get title(): string;
+    /**
+     * Short name of sticker set to use in `tg://addstickers?set=short_name`
+     * or `https://t.me/addstickers/short_name`
+     */
+    get shortName(): string;
+    /**
+     * List of stickers inside this sticker set
+     *
+     * @throws MtEmptyError
+     *     In case this object does not contain info about stickers (i.e. {@link isFull} = false)
+     */
+    get stickers(): ReadonlyArray<StickerInfo>;
+    /** Cover stickers of the sticker set. Not the same as {@link thumbnails} */
+    get covers(): ReadonlyArray<Sticker>;
+    /**
+     * Available sticker set thumbnails.
+     *
+     * Returns empty array if not available
+     * (i.e. first sticker should be used as thumbnail)
+     */
+    get thumbnails(): ReadonlyArray<Thumbnail>;
+    /**
+     * Get a sticker set 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;
+    /**
+     * Find stickers given their emoji.
+     *
+     * @param emoji  Emoji to search for
+     * @throws MtEmptyError
+     *     In case this object does not contain info about stickers (i.e. {@link isFull} = false)
+     */
+    getStickersByEmoji(emoji: string): StickerInfo[];
+    private _getInputDocument;
+}
+export interface InputStickerSetItem {
+    /**
+     * File containing the sticker.
+     *
+     * For normal stickers: must be a `.png` or `.webp` file
+     * up to 512kb, having both dimensions `<=512px`, and having
+     * one of the dimensions `==512px`
+     *
+     * For animated stickers: must be a `.tgs` file
+     * up to 64kb, having canvas dimensions exactly
+     * `512x512`px, duration no more than 3 seconds
+     * and animated at 60fps ([source](https://core.telegram.org/animated_stickers#technical-requirements))
+     */
+    file: InputFileLike;
+    /**
+     * One or more emojis that represent this sticker
+     */
+    emojis: string;
+    /**
+     * In case this is a mask sticker,
+     * position of the mask
+     */
+    maskPosition?: MaskPosition;
+}

package/highlevel/types/misc/takeout-session.d.cts

@@ -0,0 +1,49 @@
+import { tl } from '@mtcute/tl';
+import { RpcCallOptions } from '../../../network/network-manager.js';
+import { MustEqual } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Account takeout session
+ */
+export declare class TakeoutSession {
+    readonly client: ITelegramClient;
+    /**
+     * Takeout session id
+     */
+    readonly id: tl.Long;
+    constructor(client: ITelegramClient, session: tl.account.RawTakeout);
+    /**
+     * Make an API call using this takeout session
+     *
+     * This method just wraps the query into `invokeWithTakeout`
+     * and passes the control down to {@link TelegramClient.call}.
+     *
+     * @param message  RPC method to call
+     * @param params  Additional call parameters
+     */
+    call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']]>;
+    /**
+     * Create a proxy over {@link TelegramClient}
+     * that will use this takeout session to call methods.
+     *
+     * You can optionally provide a function to check if some
+     * RPC method should be called via a takeout session or directly,
+     * otherwise all methods are called through the takeout session.
+     *
+     * > **Note**: This will return a `Proxy` object that
+     * > overrides `call` method. Using this method requires
+     * > that your target environment supports `Proxy` and `Reflect` APIs
+     *
+     * @param predicate
+     *     Function that given the RPC call should determine whether
+     *     that call should be called via takeout session or not.
+     *     Returning `true` will use takeout session, `false` will not.
+     */
+    createProxy(predicate?: (obj: tl.TlObject) => boolean): ITelegramClient;
+    /**
+     * Finish account takeout session
+     *
+     * @param success  Whether the data was successfully exported
+     */
+    finish(success?: boolean): Promise<void>;
+}

package/highlevel/types/peers/bot-info.d.cts

@@ -0,0 +1,21 @@
+import { tl } from '@mtcute/tl';
+import { Video } from '../media/video.js';
+import { Photo } from '../media/photo.js';
+/** Information about a bot */
+export declare class BotInfo {
+    readonly raw: tl.RawBotInfo;
+    constructor(raw: tl.RawBotInfo);
+    /** Whether the bot has preview medias available */
+    get hasPreviewMedia(): boolean;
+    /** ID of the bot */
+    get id(): number;
+    get description(): string;
+    get descriptionPhoto(): Photo | null;
+    get descriptionVideo(): Video | null;
+    /** List of the bot's registered commands */
+    get commands(): tl.TypeBotCommand[];
+    /** Action to be performed when the bot's menu button is pressed */
+    get menuButton(): tl.TypeBotMenuButton | null;
+    /** URL of the bot's privacy policy */
+    get privacyPolicyUrl(): string | null;
+}

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

@@ -0,0 +1,25 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Information about colors of a chat
+ */
+export declare class ChatColors {
+    private readonly _peerId;
+    readonly raw?: tl.RawPeerColor | undefined;
+    constructor(_peerId: number, raw?: tl.RawPeerColor | undefined);
+    /**
+     * Color ID
+     *
+     * Note that this value is **not** an RGB color representation. Instead, it is
+     * a number which should be used to pick a color from a predefined
+     * list of colors:
+     *  - `0-6` are the default colors used by Telegram clients:
+     *    `red, orange, purple, green, sea, blue, pink`
+     *  - `>= 7` are returned by `help.getAppConfig`.
+     */
+    get color(): number;
+    /**
+     * ID of the emoji that should be used as a background pattern
+     * when rendering the color
+     */
+    get backgroundEmojiId(): tl.Long | null;
+}

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

@@ -0,0 +1,279 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers-index.js';
+import { Photo } from '../../media/photo.js';
+import { Message } from '../../messages/message.js';
+import { ChatInviteLink } from '../chat-invite-link.js';
+import { ChatLocation } from '../chat-location.js';
+import { ChatMember } from '../chat-member.js';
+import { ChatPermissions } from '../chat-permissions.js';
+import { ForumTopic } from '../forum-topic.js';
+import { User } from '../user.js';
+/** A user has joined the channel (in the case of big groups, info of the user that has joined isn't shown) */
+export interface ChatActionUserJoined {
+    type: 'user_joined';
+}
+/** A user has joined the channel using an invite link */
+export interface ChatActionUserJoinedInvite {
+    type: 'user_joined_invite';
+    /** Invite link user to join */
+    link: ChatInviteLink;
+}
+/** A user has joined the channel using an invite link and was approved by an admin */
+export interface ChatActionUserJoinedApproved {
+    type: 'user_joined_approved';
+    /** Invite link user to join */
+    link: ChatInviteLink;
+    /** User who approved the join */
+    approvedBy: User;
+}
+/** A user has left the channel (in the case of big groups, info of the user that has joined isn't shown) */
+export interface ChatActionUserLeft {
+    type: 'user_left';
+}
+/** A user was invited to the channel */
+export interface ChatActionUserInvited {
+    type: 'user_invited';
+    /** Member who has been invited */
+    member: ChatMember;
+}
+/** Channel title has been changed */
+export interface ChatActionTitleChanged {
+    type: 'title_changed';
+    /** Old chat title */
+    old: string;
+    /** New chat title */
+    new: string;
+}
+/** Channel description has been changed */
+export interface ChatActionDescriptionChanged {
+    type: 'description_changed';
+    /** Old description */
+    old: string;
+    /** New description */
+    new: string;
+}
+/** Channel username has been changed */
+export interface ChatActionUsernameChanged {
+    type: 'username_changed';
+    /** Old username */
+    old: string;
+    /** New username */
+    new: string;
+}
+/** Channel username list has been changed */
+export interface ChatActionUsernamesChanged {
+    type: 'usernames_changed';
+    /** Old username */
+    old: string[];
+    /** New username */
+    new: string[];
+}
+/** Channel photo has been changed */
+export interface ChatActionPhotoChanged {
+    type: 'photo_changed';
+    /** Old photo */
+    old: Photo;
+    /** New photo */
+    new: Photo;
+}
+/** Invites were enabled/disabled */
+export interface ChatActionInvitesToggled {
+    type: 'invites_toggled';
+    /** Old value */
+    old: boolean;
+    /** New value */
+    new: boolean;
+}
+/** Signatures were enabled/disabled */
+export interface ChatActionSignaturesToggled {
+    type: 'signatures_toggled';
+    /** Old value */
+    old: boolean;
+    /** New value */
+    new: boolean;
+}
+/** A message has been pinned */
+export interface ChatActionMessagePinned {
+    type: 'msg_pinned';
+    /** Message which was pinned */
+    message: Message;
+}
+/** A message has been edited */
+export interface ChatActionMessageEdited {
+    type: 'msg_edited';
+    /** Old message */
+    old: Message;
+    /** New message */
+    new: Message;
+}
+/** A message has been deleted */
+export interface ChatActionMessageDeleted {
+    type: 'msg_deleted';
+    /** Message which was deleted */
+    message: Message;
+}
+/** User's permissions were changed */
+export interface ChatActionUserPermissionsChanged {
+    type: 'user_perms_changed';
+    /** Information about member before change */
+    old: ChatMember;
+    /** Information about member after change */
+    new: ChatMember;
+}
+/** User's admin permissions were changed */
+export interface ChatActionUserAdminPermissionsChanged {
+    type: 'user_admin_perms_changed';
+    /** Information about member before change */
+    old: ChatMember;
+    /** Information about member after change */
+    new: ChatMember;
+}
+/** Group stickerset has been changed */
+export interface ChatActionStickersetChanged {
+    type: 'stickerset_changed';
+    /** Old stickerset */
+    old: tl.TypeInputStickerSet;
+    /** New stickerset */
+    new: tl.TypeInputStickerSet;
+}
+/** History visibility for new users has been toggled */
+export interface ChatActionHistoryToggled {
+    type: 'history_toggled';
+    /** Old value (`false` if new users can see history) */
+    old: boolean;
+    /** New value (`false` if new users can see history) */
+    new: boolean;
+}
+/** Group default permissions have been changed */
+export interface ChatActionDefaultPermissionsChanged {
+    type: 'def_perms_changed';
+    /** Old default permissions */
+    old: ChatPermissions;
+    /** New default permissions */
+    new: ChatPermissions;
+}
+/** Poll has been stopped */
+export interface ChatActionPollStopped {
+    type: 'poll_stopped';
+    /** Message containing the poll */
+    message: Message;
+}
+/** Linked chat has been changed */
+export interface ChatActionLinkedChatChanged {
+    type: 'linked_chat_changed';
+    /** ID of the old linked chat */
+    old: number;
+    /** ID of the new linked chat */
+    new: number;
+}
+/** Group location has been changed */
+export interface ChatActionLocationChanged {
+    type: 'location_changed';
+    /** Old location */
+    old: ChatLocation | null;
+    /** New location */
+    new: ChatLocation | null;
+}
+/** Group slow mode delay has been changed */
+export interface ChatActionSlowModeChanged {
+    type: 'slow_mode_changed';
+    /** Old delay (can be 0) */
+    old: number;
+    /** New delay (can be 0) */
+    new: number;
+}
+/** Group call has been started */
+export interface ChatActionCallStarted {
+    type: 'call_started';
+    /** TL object representing the call */
+    call: tl.TypeInputGroupCall;
+}
+/** Group call has ended */
+export interface ChatActionCallEnded {
+    type: 'call_ended';
+    /** TL object representing the call */
+    call: tl.TypeInputGroupCall;
+}
+/** Group call "join muted" setting has been changed */
+export interface ChatActionCallSettingChanged {
+    type: 'call_setting_changed';
+    /** Whether new call participants should join muted */
+    joinMuted: boolean;
+}
+/** Invite link has been deleted */
+export interface ChatActionInviteLinkDeleted {
+    type: 'invite_deleted';
+    /** Invite link which was deleted */
+    link: ChatInviteLink;
+}
+/** Invite link has been edited */
+export interface ChatActionInviteLinkEdited {
+    type: 'invite_edited';
+    /** Old invite link */
+    old: ChatInviteLink;
+    /** New invite link */
+    new: ChatInviteLink;
+}
+/** Invite link has been revoked */
+export interface ChatActionInviteLinkRevoked {
+    type: 'invite_revoked';
+    /** Invite link which was revoked */
+    link: ChatInviteLink;
+}
+/** History TTL has been changed */
+export interface ChatActionTtlChanged {
+    type: 'ttl_changed';
+    /** Old TTL value (can be 0) */
+    old: number;
+    /** New TTL value (can be 0) */
+    new: number;
+}
+/** Content protection has been toggled */
+export interface ChatActionNoForwardsToggled {
+    type: 'no_forwards_toggled';
+    /** New status */
+    enabled: boolean;
+}
+/** Forum has been toggled */
+export interface ChatActionForumToggled {
+    type: 'forum_toggled';
+    /** New status */
+    enabled: boolean;
+}
+/** Forum topic has been created */
+export interface ChatActionTopicCreated {
+    type: 'topic_created';
+    /** Topic that has been created */
+    topic: ForumTopic;
+}
+/** Forum topic has been edited */
+export interface ChatActionTopicEdited {
+    type: 'topic_edited';
+    /** Old topic info */
+    old: ForumTopic;
+    /** New topic info */
+    new: ForumTopic;
+}
+/** Forum topic has been edited */
+export interface ChatActionTopicDeleted {
+    type: 'topic_deleted';
+    /** Old topic info */
+    topic: ForumTopic;
+}
+/** Profile signatures were toggled in a channel ("Super Channel" mode) */
+export interface ChatActionSignatureProfilesToggled {
+    type: 'signature_profiles_toggled';
+    /** Whether signatures are enabled as of this action */
+    new: boolean;
+}
+export interface ChatActionSubscriptionExtended {
+    type: 'sub_extend';
+    /** Previous participant information */
+    prev: ChatMember;
+    /** New participant information */
+    new: ChatMember;
+}
+/** Chat event action (`null` if unsupported) */
+export type ChatAction = ChatActionUserJoined | ChatActionUserLeft | ChatActionUserInvited | ChatActionTitleChanged | ChatActionDescriptionChanged | ChatActionUsernameChanged | ChatActionUsernamesChanged | ChatActionPhotoChanged | ChatActionInvitesToggled | ChatActionSignaturesToggled | ChatActionMessagePinned | ChatActionMessageEdited | ChatActionMessageDeleted | ChatActionUserPermissionsChanged | ChatActionUserAdminPermissionsChanged | ChatActionStickersetChanged | ChatActionHistoryToggled | ChatActionDefaultPermissionsChanged | ChatActionPollStopped | ChatActionLinkedChatChanged | ChatActionLocationChanged | ChatActionSlowModeChanged | ChatActionCallStarted | ChatActionCallEnded | ChatActionCallSettingChanged | ChatActionUserJoinedInvite | ChatActionInviteLinkDeleted | ChatActionInviteLinkEdited | ChatActionInviteLinkRevoked | ChatActionUserJoinedApproved | ChatActionTtlChanged | ChatActionNoForwardsToggled | ChatActionForumToggled | ChatActionTopicCreated | ChatActionTopicEdited | ChatActionTopicDeleted | ChatActionSignatureProfilesToggled | ChatActionSubscriptionExtended | null;
+/** @internal */
+export declare function _actionFromTl(e: tl.TypeChannelAdminLogEventAction, peers: PeersIndex): ChatAction;

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

@@ -0,0 +1,10 @@
+import { tl } from '@mtcute/tl';
+import { MaybeArray } from '../../../../types/utils.js';
+import { ChatAction } from './actions.js';
+export interface ChatEventFilters {
+    serverFilter?: tl.TypeChannelAdminLogEventsFilter;
+    localFilter?: Record<string, true>;
+}
+export type InputChatEventFilters = ChatEventFilters | tl.TypeChannelAdminLogEventsFilter | MaybeArray<Exclude<ChatAction, null>['type']> | undefined;
+/** @internal */
+export declare function normalizeChatEventFilters(input: InputChatEventFilters): ChatEventFilters;