@mtcute/core 0.18.0-rc.5 → 0.18.0

package/highlevel/updates/parsed.d.cts

@@ -0,0 +1,26 @@
+import { ParsedUpdate } from '../types/updates/index.js';
+import { RawUpdateInfo } 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;
+}
+export declare function makeParsedUpdateHandler(params: ParsedUpdateHandlerParams): (update: RawUpdateInfo) => void;

package/highlevel/updates/types.d.cts

@@ -0,0 +1,147 @@
+import { AsyncLock, ConditionVariable, Deque, timers } from '@fuman/utils';
+import { tl } from '@mtcute/tl';
+import { EarlyTimer, Logger, SortedLinkedList } from '../../utils/index.js';
+import { CurrentUserInfo } from '../storage/service/current-user.js';
+import { PeersIndex } from '../types/peers/peers-index.js';
+/** Information about a raw update. */
+export declare class RawUpdateInfo {
+    /** The update */
+    readonly update: tl.TypeUpdate;
+    /** Peers that are present in the update */
+    readonly peers: PeersIndex;
+    constructor(
+    /** The update */
+    update: tl.TypeUpdate, 
+    /** Peers that are present in the update */
+    peers: PeersIndex);
+}
+/**
+ * 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;
+    auth: CurrentUserInfo | null;
+}

package/highlevel/updates/utils.d.cts

@@ -0,0 +1,21 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../types/peers/peers-index.js';
+import { PendingUpdate } from './types.js';
+export declare function messageToUpdate(message: tl.TypeMessage): tl.TypeUpdate;
+export declare function extractChannelIdFromUpdate(upd: tl.TypeUpdate): number | undefined;
+export declare function toPendingUpdate(upd: tl.TypeUpdate, peers: PeersIndex, fromDifference?: boolean): PendingUpdate;
+export declare function isMessageEmpty(upd: tl.TypeUpdate): boolean;
+/**
+ * Create a dummy `updates` container with given updates.
+ */
+export declare function createDummyUpdatesContainer(updates: tl.TypeUpdate[], seq?: number): tl.TypeUpdates;
+/**
+ * Create a dummy update from PTS and PTS count.
+ *
+ * @param pts  PTS
+ * @param ptsCount  PTS count
+ * @param channelId  Channel ID (bare), if applicable
+ */
+export declare function createDummyUpdate(pts: number, ptsCount: number, channelId?: number): tl.TypeUpdates;
+/** @internal */
+export declare function assertIsUpdatesGroup(ctx: string, upd: tl.TypeUpdates): asserts upd is tl.RawUpdates | tl.RawUpdatesCombined;

package/highlevel/utils/convert-file-id.d.cts

@@ -0,0 +1,46 @@
+import { tl } from '@mtcute/tl';
+import { tdFileId as td } from '@mtcute/file-id';
+type FileId = td.RawFullRemoteFileLocation;
+/**
+ * Convert a file ID or {@link tdFileId.RawFullRemoteFileLocation}
+ * to TL object `inputWebFileLocation`
+ *
+ * @param fileId  File ID, either parsed or as a string
+ */
+export declare function fileIdToInputWebFileLocation(fileId: string | FileId): tl.RawInputWebFileLocation;
+/**
+ * Convert a file ID or {@link tdFileId.RawFullRemoteFileLocation}
+ * to TL object representing an `InputFileLocation`
+ *
+ * @param fileId  File ID, either parsed or as a string
+ */
+export declare function fileIdToInputFileLocation(fileId: string | FileId): tl.TypeInputFileLocation;
+/**
+ * Convert a file ID or {@link tdFileId.RawFullRemoteFileLocation}
+ * to TL object `inputDocument`
+ *
+ * @param fileId  File ID, either parsed or as a string
+ */
+export declare function fileIdToInputDocument(fileId: string | FileId): tl.RawInputDocument;
+/**
+ * Convert a file ID or {@link tdFileId.RawFullRemoteFileLocation}
+ * to TL object `inputPhoto`
+ *
+ * @param fileId  File ID, either parsed or as a string
+ */
+export declare function fileIdToInputPhoto(fileId: string | FileId): tl.RawInputPhoto;
+/**
+ * Convert a file ID or {@link tdFileId.RawFullRemoteFileLocation}
+ * to TL object `inputEncryptedFile`
+ *
+ * @param fileId  File ID, either parsed or as a string
+ */
+export declare function fileIdToEncryptedFile(fileId: string | FileId): tl.RawInputEncryptedFile;
+/**
+ * Convert a file ID or {@link tdFileId.RawFullRemoteFileLocation}
+ * to TL object `inputSecureFile`
+ *
+ * @param fileId  File ID, either parsed or as a string
+ */
+export declare function fileIdToSecureFile(fileId: string | FileId): tl.RawInputSecureFile;
+export {};

package/highlevel/utils/entities.d.cts

@@ -0,0 +1,19 @@
+import { TextWithEntities } from '../types/misc/entities.js';
+/**
+ * Join multiple text parts with entities into a single text with entities,
+ * adjusting the entities' offsets accordingly.
+ *
+ * @param parts  List of text parts with entities
+ * @param delim  Delimiter to insert between parts
+ * @returns  A single text with entities
+ * @example
+ *
+ * ```ts
+ * const scoreboardText = joinTextWithEntities(
+ *   apiResult.scoreboard.map((entry) => html`<b>${entry.name}</b>: ${entry.score}`),
+ *   html`<br>`
+ * )
+ * await tg.sendText(chatId, html`<b>scoreboard:</b><br><br>${scoreboardText}`)
+ * ```
+ */
+export declare function joinTextWithEntities(parts: (string | TextWithEntities)[], delim?: string | TextWithEntities): TextWithEntities;

package/highlevel/utils/entities.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/utils/file-type.d.cts

@@ -0,0 +1,2 @@
+export declare function guessFileMime(chunk: Uint8Array): string | null;
+export declare const MIME_TO_EXTENSION: Record<string, string | undefined>;

package/highlevel/utils/file-type.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/utils/file-utils.d.cts

@@ -0,0 +1,31 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Given file size, determine the appropriate chunk size (in KB)
+ * for upload/download operations.
+ */
+export declare function determinePartSize(fileSize: number): number;
+/**
+ * Returns `true` if all bytes in `buf` are printable ASCII characters
+ */
+export declare function isProbablyPlainText(buf: Uint8Array): boolean;
+/**
+ * Convert stripped JPEG (from `photoStrippedSize`) to full JPEG
+ */
+export declare function strippedPhotoToJpg(stripped: Uint8Array): Uint8Array;
+/**
+ * Inflate compressed preview SVG path to full SVG path
+ * @param encoded
+ */
+export declare function inflateSvgPath(encoded: Uint8Array): string;
+/**
+ * Convert SVG path to SVG file
+ * @param path  SVG path
+ * @param size  Size attribute of the document, if available
+ */
+export declare function svgPathToFile(path: string, size?: tl.RawDocumentAttributeImageSize): Uint8Array;
+/**
+ * Get file name from file path
+ *
+ * @param path  File path
+ */
+export declare function extractFileName(path: string): string;

package/highlevel/utils/file-utils.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/utils/index.d.cts

@@ -0,0 +1,11 @@
+export * from './convert-file-id.js';
+export * from './entities.js';
+export * from './file-utils.js';
+export * from './inline-utils.js';
+export * from './inspectable.js';
+export * from './misc-utils.js';
+export * from './peer-utils.js';
+export * from './rps-meter.js';
+export * from './stream-utils.js';
+export * from './string-session.js';
+export * from './voice-utils.js';

package/highlevel/utils/inline-utils.d.cts

@@ -0,0 +1,14 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Parse TDLib style inline message ID
+ *
+ * @param id  Inline message ID
+ */
+export declare function parseInlineMessageId(id: string): tl.TypeInputBotInlineMessageID;
+/**
+ * Generate TDLib style inline message ID
+ *
+ * @param id  Inline message ID object
+ */
+export declare function encodeInlineMessageId(id: tl.TypeInputBotInlineMessageID): string;
+export declare function normalizeInlineId(id: string | tl.TypeInputBotInlineMessageID): tl.TypeInputBotInlineMessageID;

package/highlevel/utils/inline-utils.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/utils/inspectable.d.cts

@@ -0,0 +1,9 @@
+/**
+ * Small helper function that adds `toJSON` and `util.custom.inspect`
+ * methods to a given class based on its getters
+ *
+ * > **Note**: This means that all getters must be pure!
+ * > (getter that caches after its first invocation is also
+ * > considered pure in this case)
+ */
+export declare function makeInspectable<T>(obj: new (...args: any[]) => T, props?: (keyof T)[], hide?: (keyof T)[]): typeof obj;

package/highlevel/utils/inspectable.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/utils/memoize.d.cts

@@ -0,0 +1 @@
+export declare function memoizeGetters<T>(cls: new (...args: any[]) => T, fields: (keyof T)[]): typeof cls;

package/highlevel/utils/memoize.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/utils/misc-utils.d.cts

@@ -0,0 +1,12 @@
+import { ArrayPaginated, ArrayWithTotal, MaybeDynamic, Message } from '../types/index.js';
+/**
+ * Normalize phone number by stripping formatting
+ * @param phone  Phone number
+ */
+export declare function normalizePhoneNumber(phone: string): string;
+export declare function resolveMaybeDynamic<T>(val: MaybeDynamic<T>): Promise<T>;
+export declare function makeArrayWithTotal<T>(arr: T[], total: number): ArrayWithTotal<T>;
+export declare function makeArrayPaginated<T, Offset>(arr: T[], total: number, next?: Offset): ArrayPaginated<T, Offset>;
+export declare function normalizeDate(date: Date | number): number;
+export declare function normalizeDate(date: Date | number | undefined): number | undefined;
+export declare function normalizeMessageId(msg: Message | number | undefined): number | undefined;

package/highlevel/utils/peer-utils.d.cts

@@ -0,0 +1,11 @@
+import { InputPeerLike } from '../types/peers/index.js';
+import { tl } from '@mtcute/tl';
+export declare const INVITE_LINK_REGEX: RegExp;
+export declare function toInputPeer(res: tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel): tl.TypeInputPeer;
+export declare function toInputUser(res: tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel, input?: InputPeerLike): tl.TypeInputUser;
+export declare function toInputChannel(res: tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel, input?: InputPeerLike): tl.TypeInputChannel;
+export declare function isInputPeerUser(obj: tl.TypeInputPeer): obj is tl.RawInputPeerUser | tl.RawInputPeerUserFromMessage | tl.RawInputPeerSelf;
+export declare function isInputPeerChannel(obj: tl.TypeInputPeer): obj is tl.RawInputPeerChannel | tl.RawInputPeerChannelFromMessage;
+export declare function isInputPeerChat(obj: tl.TypeInputPeer): obj is tl.RawInputPeerChat;
+export declare function inputPeerToPeer(inp: tl.TypeInputPeer): tl.TypePeer;
+export declare function extractUsernames(obj: tl.RawUser | tl.RawChannel): string[];

package/highlevel/utils/peer-utils.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/utils/query-batcher.d.cts

@@ -0,0 +1,49 @@
+import { ITelegramClient } from '../client.types.js';
+export type BatchedQuery<T, U> = (client: ITelegramClient, item: T) => Promise<U | null>;
+/**
+ * Helper function for building batched queries.
+ *
+ * Concepts:
+ *   - "input" - items being passed to the query function
+ *   - "output" - items returned by the query function
+ *   - "key" - unique identifier of the item, which should be deriveable from both input and output.
+ *     used for matching input and output items and deduplicating them.
+ */
+export declare function batchedQuery<T, U>(params: {
+    /**
+     * Fetcher function, taking an array of input items and returning an array of output items.
+     *
+     * If some item is not found, it should be omitted from the result array,
+     * this way the corresponding request will be resolved with `null`.
+     */
+    fetch: (client: ITelegramClient, items: T[]) => Promise<U[]>;
+    /** Key derivation function for input items */
+    inputKey: (item: T, client: ITelegramClient) => string | number;
+    /** Key derivation function for output items */
+    outputKey: (item: U, client: ITelegramClient) => string | number;
+    /**
+     * Maximum number of items to be passed to the `fetcher` function at once.
+     *
+     * It is recommended to pass ~half of the maximum allowed by the server,
+     * since in some cases failing on a single item will cause the whole batch to fail.
+     *
+     * @default  Infinity
+     */
+    maxBatchSize?: number;
+    /**
+     * Maximum number of concurrently running queries.
+     *
+     * @default  1
+     */
+    maxConcurrent?: number;
+    /**
+     * In case of an error, we can try retrying the query for some items one-by-one,
+     * to avoid failing the whole batch.
+     *
+     * @param items  Items contained in the batch that failed
+     * @param err  Error that was thrown by the fetcher
+     * @returns  `true` if the query should be retried for all items, `false` if it should be retried for none,
+     *   or an array of items for which the query should be retried (waiters for other items will throw `err`).
+     */
+    retrySingleOnError?: (items: T[], err: unknown) => boolean | T[];
+}): BatchedQuery<T, U>;

package/highlevel/utils/query-batcher.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/utils/rps-meter.d.cts

@@ -0,0 +1,9 @@
+import { Deque } from '@fuman/utils';
+export declare class RpsMeter {
+    readonly size: number;
+    _hits: Deque<bigint>;
+    time: bigint;
+    constructor(size?: number, time?: number);
+    hit(): void;
+    getRps(): number;
+}

package/highlevel/utils/stream-utils.d.cts

@@ -0,0 +1 @@
+export declare function streamToBuffer(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;

package/highlevel/utils/string-session.d.cts

@@ -0,0 +1,16 @@
+import { DcOptions } from '../../utils/dcs.js';
+import { CurrentUserInfo } from '../storage/service/current-user.js';
+export interface InputStringSessionData {
+    primaryDcs?: DcOptions;
+    testMode?: boolean;
+    self?: CurrentUserInfo | null;
+    authKey: Uint8Array;
+}
+export interface StringSessionData {
+    version: number;
+    primaryDcs: DcOptions;
+    self?: CurrentUserInfo | null;
+    authKey: Uint8Array;
+}
+export declare function writeStringSession(data: StringSessionData): string;
+export declare function readStringSession(data: string | InputStringSessionData): StringSessionData;

package/highlevel/utils/string-session.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/utils/voice-utils.d.cts

@@ -0,0 +1,14 @@
+/**
+ * Decode 5-bit encoded voice message waveform into
+ * an array of waveform values (0-32).
+ *
+ * @param wf  Encoded waveform
+ */
+export declare function decodeWaveform(wf: Uint8Array): number[];
+/**
+ * Encode an array of waveform values into
+ * 5-bit encoded voice message waveform into
+ *
+ * @param wf  Waveform values
+ */
+export declare function encodeWaveform(wf: number[]): Uint8Array;

package/highlevel/utils/voice-utils.test.d.cts

@@ -0,0 +1 @@
+export {};

package/highlevel/worker/app-config.d.cts

@@ -0,0 +1,9 @@
+import { PublicPart } from '../../types/utils.js';
+import { AppConfigManager } from '../managers/app-config-manager.js';
+import { WorkerInvoker } from './invoker.js';
+export declare class AppConfigManagerProxy implements PublicPart<AppConfigManager> {
+    readonly invoker: WorkerInvoker;
+    readonly get: AppConfigManager['get'];
+    readonly getField: AppConfigManager['getField'];
+    constructor(invoker: WorkerInvoker);
+}

package/highlevel/worker/errors.d.cts

@@ -0,0 +1,8 @@
+export interface SerializedError {
+    name: string;
+    message: string;
+    stack?: string;
+    custom?: Record<string, unknown>;
+}
+export declare function serializeError(error: unknown): SerializedError;
+export declare function deserializeError(error: SerializedError): Error;

package/highlevel/worker/index.d.cts

@@ -0,0 +1,3 @@
+export * from './port.js';
+export * from './protocol.js';
+export * from './worker.js';

package/highlevel/worker/invoker.d.cts

@@ -0,0 +1,18 @@
+import { SendFn, WorkerInboundMessage, WorkerOutboundMessage } from './protocol.js';
+export type InvokeTarget = Extract<WorkerInboundMessage, {
+    type: 'invoke';
+}>['target'];
+export declare class WorkerInvoker {
+    private send;
+    constructor(send: SendFn);
+    private _nextId;
+    private _pending;
+    private _invoke;
+    invoke(target: InvokeTarget, method: string, args: unknown[]): Promise<unknown>;
+    invokeVoid(target: InvokeTarget, method: string, args: unknown[]): void;
+    invokeWithAbort(target: InvokeTarget, method: string, args: unknown[], abortSignal: AbortSignal): Promise<unknown>;
+    handleResult(msg: Extract<WorkerOutboundMessage, {
+        type: 'result';
+    }>): void;
+    makeBinder<T>(target: InvokeTarget): <K extends keyof T>(method: K, isVoid?: boolean) => T[K];
+}

package/highlevel/worker/port.d.cts

@@ -0,0 +1,60 @@
+import { tl } from '@mtcute/tl';
+import { RpcCallOptions } from '../../network/network-manager.js';
+import { ICorePlatform } from '../../types/platform.js';
+import { MustEqual } from '../../types/utils.js';
+import { ConnectionState, ITelegramClient } from '../client.types.js';
+import { RawUpdateInfo } from '../updates/types.js';
+import { ClientMessageHandler, SendFn, SomeWorker, WorkerCustomMethods } from './protocol.js';
+import { Emitter } from '@fuman/utils';
+import { LogManager } from '../../utils/logger.js';
+import { TimersManager } from '../managers/timers.js';
+import { AppConfigManagerProxy } from './app-config.js';
+import { TelegramStorageProxy } from './storage.js';
+export interface TelegramWorkerPortOptions {
+    worker: SomeWorker;
+    platform: ICorePlatform;
+}
+export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMethods> implements ITelegramClient {
+    readonly options: TelegramWorkerPortOptions;
+    readonly log: LogManager;
+    readonly platform: ICorePlatform;
+    private _connection;
+    private _invoker;
+    readonly storage: TelegramStorageProxy;
+    readonly appConfig: AppConfigManagerProxy;
+    readonly timers: TimersManager;
+    readonly prepare: ITelegramClient['prepare'];
+    private _connect;
+    readonly close: ITelegramClient['close'];
+    readonly notifyLoggedIn: ITelegramClient['notifyLoggedIn'];
+    readonly notifyLoggedOut: ITelegramClient['notifyLoggedOut'];
+    readonly notifyChannelOpened: ITelegramClient['notifyChannelOpened'];
+    readonly notifyChannelClosed: ITelegramClient['notifyChannelClosed'];
+    readonly importSession: ITelegramClient['importSession'];
+    readonly exportSession: ITelegramClient['exportSession'];
+    readonly handleClientUpdate: ITelegramClient['handleClientUpdate'];
+    readonly getApiCrenetials: ITelegramClient['getApiCrenetials'];
+    readonly getPoolSize: ITelegramClient['getPoolSize'];
+    readonly getPrimaryDcId: ITelegramClient['getPrimaryDcId'];
+    readonly changePrimaryDc: ITelegramClient['changePrimaryDc'];
+    readonly computeSrpParams: ITelegramClient['computeSrpParams'];
+    readonly computeNewPasswordHash: ITelegramClient['computeNewPasswordHash'];
+    readonly startUpdatesLoop: ITelegramClient['startUpdatesLoop'];
+    readonly stopUpdatesLoop: ITelegramClient['stopUpdatesLoop'];
+    readonly getMtprotoMessageId: ITelegramClient['getMtprotoMessageId'];
+    readonly recreateDc: ITelegramClient['recreateDc'];
+    private _abortController;
+    readonly stopSignal: AbortSignal;
+    constructor(options: TelegramWorkerPortOptions);
+    call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']]>;
+    abstract connectToWorker(worker: SomeWorker, handler: ClientMessageHandler): [SendFn, () => void];
+    onServerUpdate: Emitter<tl.TypeUpdates>;
+    onRawUpdate: Emitter<RawUpdateInfo>;
+    onConnectionState: Emitter<ConnectionState>;
+    onError: Emitter<Error>;
+    private _onMessage;
+    private _destroyed;
+    destroy(terminate?: boolean): void;
+    invokeCustom<T extends keyof Custom>(method: T, ...args: Parameters<Custom[T]>): Promise<ReturnType<Custom[T]>>;
+    connect(): Promise<void>;
+}