@mtcute/core 0.16.7 → 0.16.10

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

@@ -0,0 +1,107 @@
+import { BusinessConnection, Message } from '../../types/index.js';
+import { BotChatJoinRequestUpdate } from './bot-chat-join-request.js';
+import { BotStoppedUpdate } from './bot-stopped.js';
+import { BusinessCallbackQuery, CallbackQuery, InlineCallbackQuery } from './callback-query.js';
+import { ChatJoinRequestUpdate } from './chat-join-request.js';
+import { ChatMemberUpdate } from './chat-member-update.js';
+import { InlineQuery } from './inline-query.js';
+import { BotReactionCountUpdate, BotReactionUpdate } from './bot-reaction.js';
+import { BusinessMessage } from './business-message.js';
+import { ChosenInlineResult } from './chosen-inline-result.js';
+import { DeleteBusinessMessageUpdate } from './delete-business-message-update.js';
+import { DeleteMessageUpdate } from './delete-message-update.js';
+import { DeleteStoryUpdate } from './delete-story-update.js';
+import { HistoryReadUpdate } from './history-read-update.js';
+import { PollUpdate } from './poll-update.js';
+import { PollVoteUpdate } from './poll-vote.js';
+import { PreCheckoutQuery } from './pre-checkout-query.js';
+import { StoryUpdate } from './story-update.js';
+import { UserStatusUpdate } from './user-status-update.js';
+import { UserTypingUpdate } from './user-typing-update.js';
+export type { ChatMemberUpdateType } from './chat-member-update.js';
+export { BotChatJoinRequestUpdate, BotReactionCountUpdate, BotReactionUpdate, BotStoppedUpdate, BusinessCallbackQuery, BusinessMessage, CallbackQuery, ChatJoinRequestUpdate, ChatMemberUpdate, ChosenInlineResult, DeleteBusinessMessageUpdate, DeleteMessageUpdate, DeleteStoryUpdate, HistoryReadUpdate, InlineCallbackQuery, InlineQuery, PollUpdate, PollVoteUpdate, PreCheckoutQuery, StoryUpdate, UserStatusUpdate, UserTypingUpdate, };
+export type ParsedUpdate = {
+    name: 'new_message';
+    data: Message;
+} | {
+    name: 'edit_message';
+    data: Message;
+} | {
+    name: 'message_group';
+    data: Message[];
+} | {
+    name: 'delete_message';
+    data: DeleteMessageUpdate;
+} | {
+    name: 'chat_member';
+    data: ChatMemberUpdate;
+} | {
+    name: 'inline_query';
+    data: InlineQuery;
+} | {
+    name: 'chosen_inline_result';
+    data: ChosenInlineResult;
+} | {
+    name: 'callback_query';
+    data: CallbackQuery;
+} | {
+    name: 'inline_callback_query';
+    data: InlineCallbackQuery;
+} | {
+    name: 'business_callback_query';
+    data: BusinessCallbackQuery;
+} | {
+    name: 'poll';
+    data: PollUpdate;
+} | {
+    name: 'poll_vote';
+    data: PollVoteUpdate;
+} | {
+    name: 'user_status';
+    data: UserStatusUpdate;
+} | {
+    name: 'user_typing';
+    data: UserTypingUpdate;
+} | {
+    name: 'history_read';
+    data: HistoryReadUpdate;
+} | {
+    name: 'bot_stopped';
+    data: BotStoppedUpdate;
+} | {
+    name: 'bot_chat_join_request';
+    data: BotChatJoinRequestUpdate;
+} | {
+    name: 'chat_join_request';
+    data: ChatJoinRequestUpdate;
+} | {
+    name: 'pre_checkout_query';
+    data: PreCheckoutQuery;
+} | {
+    name: 'story';
+    data: StoryUpdate;
+} | {
+    name: 'delete_story';
+    data: DeleteStoryUpdate;
+} | {
+    name: 'bot_reaction';
+    data: BotReactionUpdate;
+} | {
+    name: 'bot_reaction_count';
+    data: BotReactionCountUpdate;
+} | {
+    name: 'business_connection';
+    data: BusinessConnection;
+} | {
+    name: 'new_business_message';
+    data: BusinessMessage;
+} | {
+    name: 'edit_business_message';
+    data: BusinessMessage;
+} | {
+    name: 'business_message_group';
+    data: BusinessMessage[];
+} | {
+    name: 'delete_business_message';
+    data: DeleteBusinessMessageUpdate;
+};

package/highlevel/types/updates/inline-query.d.ts

@@ -0,0 +1,42 @@
+import { tl } from '@mtcute/tl';
+import { Location } from '../media/location.js';
+import { PeerType, PeersIndex, User } from '../peers/index.js';
+export declare class InlineQuery {
+    readonly raw: tl.RawUpdateBotInlineQuery;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateBotInlineQuery, _peers: PeersIndex);
+    /**
+     * Unique query ID
+     */
+    get id(): tl.Long;
+    /**
+     * User who sent this query
+     */
+    get user(): User;
+    /**
+     * Text of the query (0-512 characters)
+     */
+    get query(): string;
+    /**
+     * Attached geolocation.
+     *
+     * Only used in case the bot requested user location
+     */
+    get location(): Location | null;
+    /**
+     * Inline query scroll offset, controlled by the bot
+     */
+    get offset(): string;
+    /**
+     * Peer type from which this query was sent.
+     *
+     * Can be:
+     *  - `bot`: Query was sent in this bot's PM
+     *  - `user`: Query was sent in somebody's PM
+     *  - `group`: Query was sent in a legacy group
+     *  - `supergroup`: Query was sent in a supergroup
+     *  - `channel`: Query was sent in a channel
+     *  - `null`, in case this information is not available
+     */
+    get peerType(): PeerType | null;
+}

package/highlevel/types/updates/parse-update.d.ts

@@ -0,0 +1,4 @@
+import { tl } from '@mtcute/tl';
+import { ParsedUpdate, PeersIndex } from '../index.js';
+/** @internal */
+export declare function _parseUpdate(update: tl.TypeUpdate, peers: PeersIndex): ParsedUpdate | null;

package/highlevel/types/updates/poll-update.d.ts

@@ -0,0 +1,39 @@
+import { tl } from '@mtcute/tl';
+import { Poll } from '../media/poll.js';
+import { PeersIndex } from '../peers/peers-index.js';
+/**
+ * Poll state has changed (stopped, somebody
+ * has voted in an anonymous poll, etc.)
+ *
+ * Bots only receive updates about
+ * polls which were sent by this bot
+ */
+export declare class PollUpdate {
+    readonly raw: tl.RawUpdateMessagePoll;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateMessagePoll, _peers: PeersIndex);
+    /**
+     * Unique poll ID
+     */
+    get pollId(): tl.Long;
+    /**
+     * Whether this is a shortened version of update, not containing the poll itself.
+     */
+    get isShort(): boolean;
+    /**
+     * The poll.
+     *
+     * When {@link isShort} is set, mtcute creates a stub poll
+     * with empty question, answers and flags
+     * (like `quiz`, `public`, etc.)
+     *
+     * If you need access to them, you should
+     * map the {@link pollId} with full poll on your side
+     * (e.g. in a database) and fetch from there.
+     *
+     * Bot API and TDLib do basically the same internally,
+     * and thus are able to always provide them,
+     * but mtcute currently does not have a way to do that.
+     */
+    get poll(): Poll;
+}

package/highlevel/types/updates/poll-vote.d.ts

@@ -0,0 +1,52 @@
+import { tl } from '@mtcute/tl';
+import { Peer, PeersIndex } from '../peers/index.js';
+/**
+ * Some user has voted in a public poll.
+ *
+ * Bots only receive new votes in polls
+ * that were sent by this bot.
+ */
+export declare class PollVoteUpdate {
+    readonly raw: tl.RawUpdateMessagePollVote;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateMessagePollVote, _peers: PeersIndex);
+    /**
+     * Unique poll ID
+     */
+    get pollId(): tl.Long;
+    /**
+     * Peer who has voted
+     */
+    get peer(): Peer;
+    /**
+     * Answers that the user has chosen.
+     *
+     * Note that due to incredible Telegram APIs, you
+     * have to have the poll cached to be able to properly
+     * tell which answers were chosen, since in the API
+     * there are just arbitrary `Buffer`s, which are
+     * defined by the client.
+     *
+     * However, most of the major implementations
+     * (tested with TDLib and Bot API, official apps
+     * for Android, Desktop, iOS/macOS) and mtcute
+     * (by default) create `option` as a one-byte `Buffer`,
+     * incrementing from `48` (ASCII `0`) up to `57` (ASCII `9`),
+     * and ASCII representation would define index in the array.
+     * Meaning, if `chosen[0][0] === 48` or `chosen[0].toString() === '0'`,
+     * then the first answer (indexed with `0`) was chosen. To get the index,
+     * you simply subtract `48` from the first byte.
+     *
+     * This might break at any time, but seems to be consistent for now.
+     * To get chosen answer indexes derived as before, use {@link chosenIndexesAuto}.
+     */
+    get chosen(): ReadonlyArray<Uint8Array>;
+    /**
+     * Indexes of the chosen answers, derived based on observations
+     * described in {@link chosen}.
+     * This might break at any time, but seems to be consistent for now.
+     *
+     * If something does not add up, {@link MtUnsupportedError} is thrown
+     */
+    get chosenIndexesAuto(): ReadonlyArray<number>;
+}

package/highlevel/types/updates/pre-checkout-query.d.ts

@@ -0,0 +1,36 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex, User } from '../peers/index.js';
+export declare class PreCheckoutQuery {
+    readonly raw: tl.RawUpdateBotPrecheckoutQuery;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateBotPrecheckoutQuery, _peers: PeersIndex);
+    /**
+     * ID of the query
+     */
+    get queryId(): tl.Long;
+    /**
+     * ID of the user who sent the query
+     */
+    get userId(): number;
+    /**
+     * User who sent the query
+     */
+    get user(): User;
+    /**
+     * Bot-defined payload of the original invoice
+     * (see {@link InputMediaInvoice.payload})
+     */
+    get payload(): Uint8Array;
+    /**
+     * User-provided payment info (like name, phone, shipping address, etc.)
+     */
+    get paymentInfo(): tl.RawPaymentRequestedInfo | null;
+    /**
+     * Currency of the payment
+     */
+    get currency(): string;
+    /**
+     * Total price of the payment
+     */
+    get totalAmount(): tl.Long;
+}

package/highlevel/types/updates/story-update.d.ts

@@ -0,0 +1,22 @@
+import { tl } from '@mtcute/tl';
+import { Peer, PeersIndex } from '../../types/peers/index.js';
+import { Story } from '../../types/stories/index.js';
+/**
+ * A story was posted or edited
+ *
+ * > **Note**: Currently the only way to reliably test if this is a new story or an update
+ * > is to store known stories IDs and compare them to the one in the update.
+ */
+export declare class StoryUpdate {
+    readonly raw: tl.RawUpdateStory;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawUpdateStory, _peers: PeersIndex);
+    /**
+     * Peer that owns these stories.
+     */
+    get peer(): Peer;
+    /**
+     * Story that was posted or edited.
+     */
+    get story(): Story;
+}

package/highlevel/types/updates/user-status-update.d.ts

@@ -0,0 +1,28 @@
+import { tl } from '@mtcute/tl';
+import { UserStatus } from '../peers/index.js';
+/**
+ * User status has changed
+ */
+export declare class UserStatusUpdate {
+    readonly raw: tl.RawUpdateUserStatus;
+    constructor(raw: tl.RawUpdateUserStatus);
+    /**
+     * ID of the user whose status has updated
+     */
+    get userId(): number;
+    private get _parsedStatus();
+    /**
+     * User's new Last Seen & Online status
+     */
+    get status(): UserStatus;
+    /**
+     * 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;
+}

package/highlevel/types/updates/user-typing-update.d.ts

@@ -0,0 +1,31 @@
+import { tl } from '@mtcute/tl';
+import { BasicPeerType } from '../../../types/peers.js';
+import { TypingStatus } from '../peers/index.js';
+/**
+ * User's typing status has changed.
+ *
+ * This update is valid for 6 seconds.
+ */
+export declare class UserTypingUpdate {
+    readonly raw: tl.RawUpdateUserTyping | tl.RawUpdateChatUserTyping | tl.RawUpdateChannelUserTyping;
+    constructor(raw: tl.RawUpdateUserTyping | tl.RawUpdateChatUserTyping | tl.RawUpdateChannelUserTyping);
+    /**
+     * ID of the user whose typing status changed
+     */
+    get userId(): number;
+    /**
+     * Marked ID of the chat where the user is typing,
+     *
+     * If the user is typing in PMs, this will
+     * equal to {@link userId}
+     */
+    get chatId(): number;
+    /**
+     * Type of the chat where this event has occurred
+     */
+    get chatType(): BasicPeerType;
+    /**
+     * Current typing status
+     */
+    get status(): TypingStatus;
+}

package/highlevel/types/utils.d.ts

@@ -0,0 +1,12 @@
+import { MaybePromise } from '../../types/utils.js';
+export type MaybeDynamic<T> = MaybePromise<T> | (() => MaybePromise<T>);
+export type ArrayWithTotal<T> = T[] & {
+    total: number;
+};
+export type ArrayPaginated<T, Offset> = T[] & {
+    total: number;
+    next?: Offset;
+};
+export type ParametersSkip1<T> = T extends (a: any, ...args: infer P) => any ? P : never;
+export type ParametersSkip2<T> = T extends (a: any, b: any, ...args: infer P) => any ? P : never;
+export type ParametersSkip3<T> = T extends (a: any, b: any, c: any, ...args: infer P) => any ? P : never;

package/highlevel/updates/manager.d.ts

@@ -0,0 +1,124 @@
+import { tl } from '@mtcute/tl';
+import { Logger, AsyncLock, ConditionVariable, Deque, EarlyTimer, SortedLinkedList } from '../../utils/index.js';
+import { BaseTelegramClient } from '../base.js';
+import { CurrentUserInfo } from '../storage/service/current-user.js';
+import { PeersIndex } from '../types/peers/peers-index.js';
+import { PendingUpdate, PendingUpdateContainer, RawUpdateHandler, UpdatesManagerParams } from './types.js';
+import * as timers from '../../utils/timers.js';
+export declare class UpdatesManager {
+    readonly client: BaseTelegramClient;
+    readonly params: UpdatesManagerParams;
+    updatesLoopActive: boolean;
+    updatesLoopCv: ConditionVariable;
+    postponedTimer: EarlyTimer;
+    hasTimedoutPostponed: boolean;
+    pendingUpdateContainers: SortedLinkedList<PendingUpdateContainer>;
+    pendingPtsUpdates: SortedLinkedList<PendingUpdate>;
+    pendingPtsUpdatesPostponed: SortedLinkedList<PendingUpdate>;
+    pendingQtsUpdates: SortedLinkedList<PendingUpdate>;
+    pendingQtsUpdatesPostponed: SortedLinkedList<PendingUpdate>;
+    pendingUnorderedUpdates: Deque<PendingUpdate>;
+    noDispatchEnabled: boolean;
+    noDispatchMsg: Map<number, Set<number>>;
+    noDispatchPts: Map<number, Set<number>>;
+    noDispatchQts: Set<number>;
+    lock: AsyncLock;
+    pts?: number;
+    qts?: number;
+    date?: number;
+    seq?: number;
+    oldPts?: number;
+    oldQts?: number;
+    oldDate?: number;
+    oldSeq?: number;
+    catchingUp: boolean;
+    catchUpOnStart: boolean;
+    cpts: Map<number, number>;
+    cptsMod: Map<number, number>;
+    channelDiffTimeouts: Map<number, timers.Timer>;
+    channelsOpened: Map<number, number>;
+    log: Logger;
+    private _handler;
+    private _onCatchingUp;
+    private _channelPtsLimit;
+    auth?: CurrentUserInfo | null;
+    keepAliveInterval?: timers.Interval;
+    constructor(client: BaseTelegramClient, params?: UpdatesManagerParams);
+    setHandler(handler: RawUpdateHandler): void;
+    getHandler(): RawUpdateHandler;
+    onCatchingUp(handler: (catchingUp: boolean) => void): void;
+    destroy(): void;
+    notifyLoggedIn(self: CurrentUserInfo): void;
+    notifyLoggedOut(): void;
+    prepare(): Promise<void>;
+    private _onKeepAlive;
+    /**
+     * Start updates loop.
+     *
+     * You must first call {@link enableUpdatesProcessing} to use this method.
+     *
+     * It is recommended to use this method in callback to {@link start},
+     * or otherwise make sure the user is logged in.
+     *
+     * > **Note**: If you are using {@link UpdatesManagerParams.catchUp} option,
+     * > catching up will be done in background, you can't await it.
+     * > Instead, listen for the `updating` and `connected` connection state events.
+     */
+    startLoop(): Promise<void>;
+    /**
+     * **ADVANCED**
+     *
+     * Manually stop updates loop.
+     * Usually done automatically when stopping the client with {@link close}
+     */
+    stopLoop(): void;
+    /**
+     * Catch up with the server by loading missed updates.
+     *.
+     * > **Note**: In case the storage was not properly
+     * > closed the last time, "catching up" might
+     * > result in duplicate updates.
+     */
+    catchUp(): void;
+    handleClientUpdate(update: tl.TypeUpdates, noDispatch?: boolean): void;
+    handleUpdate(update: tl.TypeUpdates): void;
+    /**
+     * **ADVANCED**
+     *
+     * Notify the updates manager that some channel was "opened".
+     * Channel difference for "opened" channels will be fetched on a regular basis.
+     * This is a low-level method, prefer using {@link openChat} instead.
+     *
+     * Channel must be resolve-able with `resolvePeer` method (i.e. be in cache);
+     * base chat PTS must either be passed (e.g. from {@link Dialog}), or cached in storage.
+     *
+     * @param channelId  Bare ID of the channel
+     * @param pts  PTS of the channel, if known (e.g. from {@link Dialog})
+     * @returns `true` if the channel was opened for the first time, `false` if it is already opened
+     */
+    notifyChannelOpened(channelId: number, pts?: number): boolean;
+    /**
+     * **ADVANCED**
+     *
+     * Notify the updates manager that some channel was "closed".
+     * Basically the opposite of {@link notifyChannelOpened}.
+     * This is a low-level method, prefer using {@link closeChat} instead.
+     *
+     * @param channelId  Bare channel ID
+     * @returns `true` if the chat was closed for the last time, `false` otherwise
+     */
+    notifyChannelClosed(channelId: number): boolean;
+    _fetchUpdatesState(): Promise<void>;
+    _loadUpdatesStorage(): Promise<void>;
+    _saveUpdatesStorage(save?: boolean): Promise<void>;
+    _addToNoDispatchIndex(updates?: tl.TypeUpdates): void;
+    _fetchMissingPeers(upd: tl.TypeUpdate, peers: PeersIndex, allowMissing?: boolean): Promise<Set<number>>;
+    _storeMessageReferences(msg: tl.TypeMessage): Promise<void>;
+    _fetchChannelDifference(channelId: number, fallbackPts?: number): Promise<boolean>;
+    _fetchChannelDifferenceLater(requestedDiff: Map<number, Promise<void>>, channelId: number, fallbackPts?: number): void;
+    _fetchChannelDifferenceViaUpdate(channelId: number, pts?: number): void;
+    _fetchDifference(requestedDiff: Map<number, Promise<void>>): Promise<void>;
+    _fetchDifferenceLater(requestedDiff: Map<number, Promise<void>>): void;
+    _onUpdate(pending: PendingUpdate, requestedDiff: Map<number, Promise<void>>, postponed?: boolean, unordered?: boolean): Promise<void>;
+    _loop(): Promise<void>;
+}

package/highlevel/updates/parsed.d.ts

@@ -0,0 +1,32 @@
+import { ParsedUpdate } from '../types/updates/index.js';
+import { RawUpdateHandler } from './types.js';
+export interface ParsedUpdateHandlerParams {
+    /**
+     * When non-zero, allows the library to automatically handle Telegram
+     * media groups (e.g. albums) in {@link MessageGroup} updates
+     * in a given time interval (in ms).
+     *
+     * > **Note**: this does not catch messages that happen to be consecutive,
+     * > only messages belonging to the same "media group".
+     *
+     * This will cause up to `messageGroupingInterval` delay
+     * in handling media group messages.
+     *
+     * This option only applies to `new_message` updates,
+     * and the updates being grouped **will not** be dispatched on their own.
+     *
+     * Recommended value is 250 ms.
+     *
+     * @default  0 (disabled)
+     */
+    messageGroupingInterval?: number;
+    /** Handler for parsed updates */
+    onUpdate: (update: ParsedUpdate) => void;
+    /**
+     * Handler for raw updates.
+     *
+     * Note that this handler will be called **before** the parsed update handler.
+     */
+    onRawUpdate?: RawUpdateHandler;
+}
+export declare function makeParsedUpdateHandler(params: ParsedUpdateHandlerParams): RawUpdateHandler;

package/highlevel/updates/types.d.ts

@@ -0,0 +1,142 @@
+import { tl } from '@mtcute/tl';
+import { AsyncLock, ConditionVariable, Deque, EarlyTimer, Logger, SortedLinkedList, timers } from '../../utils/index.js';
+import { CurrentUserInfo } from '../storage/service/current-user.js';
+import { PeersIndex } from '../types/peers/peers-index.js';
+/**
+ * Function to be called for each update.
+ *
+ * @param upd  The update
+ * @param peers  Peers that are present in the update
+ */
+export type RawUpdateHandler = (upd: tl.TypeUpdate, peers: PeersIndex) => void;
+/**
+ * Parameters for the updates manager
+ */
+export interface UpdatesManagerParams {
+    /**
+     * **ADVANCED**
+     *
+     * Whether to globally disable no-dispatch mechanism.
+     *
+     * No-dispatch is a mechanism that allows you to call methods
+     * that return updates and correctly handle them, without
+     * actually dispatching them to the event handlers.
+     *
+     * In other words, the following code will work differently:
+     * ```ts
+     * dp.onNewMessage(console.log)
+     * console.log(await tg.sendText('me', 'hello'))
+     * ```
+     * - if `disableNoDispatch` is `true`, the sent message will be
+     *   dispatched to the event handler, thus it will be printed twice
+     * - if `disableNoDispatch` is `false`, the sent message will not be
+     *   dispatched to the event handler, thus it will onlt be printed once
+     *
+     * Disabling it may also improve performance, but it's not guaranteed.
+     *
+     * > **Note**: you can disable this on per-request basis by passing
+     * > `shouldDispatch: true` to the method call that accepts it.
+     * > For some methods you need to always pass `shouldDispatch: true` explicitly.
+     * > This is noted in the corresponding method's documentation by "Doesn't follow `disableNoDispatch`"
+     *
+     * @default false
+     */
+    disableNoDispatch?: boolean;
+    /**
+     * **ADVANCED**
+     *
+     * PTS limit for `getChannelDifference` requests (max. 100000).
+     * When there are more updates than this limit, the library will
+     * skip some of them.
+     * According to the [official docs](https://core.telegram.org/method/updates.getChannelDifference),
+     * "Ordinary (non-bot) users are supposed to pass `10-100`", so passing >100
+     * for users may lead to issues.
+     *
+     * @default 100 for users, 100000 for bots
+     */
+    channelPtsLimit?: number | ((channelId: number) => number);
+    /**
+     * **ADVANCED**
+     *
+     * Whenever an `updates.channelDifferenceTooLong` is received,
+     * the library isn't able to efficiently handle it on its own,
+     * and will call this function for you to handle it instead.
+     *
+     * [See docs](https://core.telegram.org/constructor/updates.channelDifferenceTooLong)
+     */
+    onChannelTooLong?: (channelId: number, update: tl.updates.RawChannelDifferenceTooLong) => void;
+    /**
+     * **ADVANCED**
+     *
+     * When `openChat` method is used on a client, the library will
+     * set up a timer to periodically fetch the new updates.
+     * By default, it will respect the value provided by the server,
+     * but it some cases you may want to override it (e.g. decrease it to
+     * poll more often and potentially get updates faster).
+     *
+     * The returned value is treated as seconds.
+     */
+    overrideOpenChatTimeout?: (upd: tl.updates.TypeChannelDifference) => number;
+    /**
+     * Whether to catch up with missed updates when starting updates loop.
+     *
+     * > **Note**: In case the storage was not properly closed the last time,
+     * > "catching up" might result in duplicate updates.
+     */
+    catchUp?: boolean;
+}
+/** @internal */
+export interface PendingUpdateContainer {
+    upd: tl.TypeUpdates;
+    seqStart: number;
+    seqEnd: number;
+}
+/** @internal */
+export interface PendingUpdate {
+    update: tl.TypeUpdate;
+    channelId?: number;
+    pts?: number;
+    ptsBefore?: number;
+    qts?: number;
+    qtsBefore?: number;
+    timeout?: number;
+    peers: PeersIndex;
+    fromDifference: boolean;
+}
+/** @internal */
+export interface UpdatesState {
+    updatesLoopActive: boolean;
+    updatesLoopCv: ConditionVariable;
+    postponedTimer: EarlyTimer;
+    hasTimedoutPostponed: boolean;
+    pendingUpdateContainers: SortedLinkedList<PendingUpdateContainer>;
+    pendingPtsUpdates: SortedLinkedList<PendingUpdate>;
+    pendingPtsUpdatesPostponed: SortedLinkedList<PendingUpdate>;
+    pendingQtsUpdates: SortedLinkedList<PendingUpdate>;
+    pendingQtsUpdatesPostponed: SortedLinkedList<PendingUpdate>;
+    pendingUnorderedUpdates: Deque<PendingUpdate>;
+    noDispatchEnabled: boolean;
+    noDispatchMsg: Map<number, Set<number>>;
+    noDispatchPts: Map<number, Set<number>>;
+    noDispatchQts: Set<number>;
+    lock: AsyncLock;
+    pts?: number;
+    qts?: number;
+    date?: number;
+    seq?: number;
+    oldPts?: number;
+    oldQts?: number;
+    oldDate?: number;
+    oldSeq?: number;
+    selfChanged: boolean;
+    catchUpChannels: boolean;
+    catchUpOnStart: boolean;
+    cpts: Map<number, number>;
+    cptsMod: Map<number, number>;
+    channelDiffTimeouts: Map<number, timers.Timer>;
+    channelsOpened: Map<number, number>;
+    log: Logger;
+    stop: () => void;
+    handler: RawUpdateHandler;
+    auth: CurrentUserInfo | null;
+}