@mtcute/core 0.5.0 → 0.7.0

package/esm/highlevel/updates/manager.d.ts

@@ -0,0 +1,120 @@
+/// <reference types="node" resolution-mode="require"/>
+import { tl } from '@mtcute/tl';
+import { 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';
+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;
+    selfChanged: boolean;
+    catchUpChannels: boolean;
+    catchUpOnStart: boolean;
+    cpts: Map<number, number>;
+    cptsMod: Map<number, number>;
+    channelDiffTimeouts: Map<number, NodeJS.Timeout>;
+    channelsOpened: Map<number, number>;
+    log: import("../../utils/logger.js").Logger;
+    private _handler;
+    auth?: CurrentUserInfo | null;
+    keepAliveInterval?: NodeJS.Timeout;
+    constructor(client: BaseTelegramClient, params?: UpdatesManagerParams);
+    setHandler(handler: RawUpdateHandler): 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.
+     */
+    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>;
+}