@mtcute/core 0.17.1 → 0.18.0

package/highlevel/worker/errors.cjs

@@ -0,0 +1,118 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const tl = require("@mtcute/tl");
+const errors$1 = require("../../types/errors.cjs");
+const errors = require("../types/errors.cjs");
+function serializeError(error) {
+  if (!(error instanceof Error)) return { name: "Error", message: String(error) };
+  const res = {
+    name: "Error",
+    message: error.message,
+    stack: error.stack
+  };
+  const ctor = error.constructor;
+  if (ctor === errors$1.MtTypeAssertionError) {
+    const _error = error;
+    res.name = "MtTypeAssertionError";
+    res.custom = {
+      context: _error.context,
+      expected: _error.expected,
+      actual: _error.actual
+    };
+  } else if (ctor === errors$1.MtTimeoutError) {
+    const _error = error;
+    res.name = "MtTimeoutError";
+    res.custom = {
+      timeout: _error.timeout
+    };
+  } else if (ctor === errors.MtMessageNotFoundError) {
+    const _error = error;
+    res.name = "MtMessageNotFoundError";
+    res.custom = {
+      peerId: _error.peerId,
+      messageId: _error.messageId,
+      context: _error.context
+    };
+  } else if (ctor === tl.tl.RpcError) {
+    res.name = "RpcError";
+    res.custom = { ...error };
+  } else if (ctor === errors$1.MtArgumentError) {
+    res.name = "MtArgumentError";
+  } else if (ctor === errors$1.MtSecurityError) {
+    res.name = "MtSecurityError";
+  } else if (ctor === errors$1.MtUnsupportedError) {
+    res.name = "MtUnsupportedError";
+  } else if (ctor === errors.MtPeerNotFoundError) {
+    res.name = "MtPeerNotFoundError";
+  } else if (ctor === errors.MtInvalidPeerTypeError) {
+    res.name = "MtInvalidPeerTypeError";
+  } else if (ctor === errors.MtEmptyError) {
+    res.name = "MtEmptyError";
+  } else if (ctor instanceof errors$1.MtcuteError) {
+    res.name = "MtcuteError";
+  }
+  return res;
+}
+function deserializeError(error) {
+  let err2;
+  switch (error.name) {
+    case "MtTypeAssertionError": {
+      const custom = error.custom;
+      err2 = new errors$1.MtTypeAssertionError(custom.context, custom.expected, custom.actual);
+      break;
+    }
+    case "MtTimeoutError": {
+      const custom = error.custom;
+      err2 = new errors$1.MtTimeoutError(custom.timeout);
+      break;
+    }
+    case "MtMessageNotFoundError": {
+      const custom = error.custom;
+      err2 = new errors.MtMessageNotFoundError(custom.peerId, custom.messageId, custom.context);
+      break;
+    }
+    case "RpcError": {
+      const custom = error.custom;
+      err2 = new tl.tl.RpcError(custom.code, custom.text);
+      err2.message = error.message;
+      for (const key in custom) {
+        if (key === "code" || key === "text") continue;
+        err2[key] = custom[key];
+      }
+      break;
+    }
+    case "MtArgumentError":
+      err2 = new errors$1.MtArgumentError();
+      break;
+    case "MtSecurityError":
+      err2 = new errors$1.MtSecurityError();
+      break;
+    case "MtUnsupportedError":
+      err2 = new errors$1.MtUnsupportedError();
+      break;
+    case "MtPeerNotFoundError":
+      err2 = new errors.MtPeerNotFoundError();
+      break;
+    case "MtInvalidPeerTypeError":
+      err2 = new errors.MtInvalidPeerTypeError("", "");
+      err2.message = error.message;
+      break;
+    case "MtEmptyError":
+      err2 = new errors.MtEmptyError();
+      break;
+    case "MtcuteError":
+      err2 = new errors$1.MtcuteError();
+      break;
+    default:
+      err2 = new Error(error.message);
+  }
+  err2.stack = error.stack;
+  return err2;
+}
+exports.deserializeError = deserializeError;
+exports.serializeError = serializeError;

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/errors.js

@@ -0,0 +1,113 @@
+import { tl } from "@mtcute/tl";
+import { MtUnsupportedError, MtSecurityError, MtArgumentError, MtTimeoutError, MtTypeAssertionError, MtcuteError } from "../../types/errors.js";
+import { MtEmptyError, MtInvalidPeerTypeError, MtPeerNotFoundError, MtMessageNotFoundError } from "../types/errors.js";
+function serializeError(error) {
+  if (!(error instanceof Error)) return { name: "Error", message: String(error) };
+  const res = {
+    name: "Error",
+    message: error.message,
+    stack: error.stack
+  };
+  const ctor = error.constructor;
+  if (ctor === MtTypeAssertionError) {
+    const _error = error;
+    res.name = "MtTypeAssertionError";
+    res.custom = {
+      context: _error.context,
+      expected: _error.expected,
+      actual: _error.actual
+    };
+  } else if (ctor === MtTimeoutError) {
+    const _error = error;
+    res.name = "MtTimeoutError";
+    res.custom = {
+      timeout: _error.timeout
+    };
+  } else if (ctor === MtMessageNotFoundError) {
+    const _error = error;
+    res.name = "MtMessageNotFoundError";
+    res.custom = {
+      peerId: _error.peerId,
+      messageId: _error.messageId,
+      context: _error.context
+    };
+  } else if (ctor === tl.RpcError) {
+    res.name = "RpcError";
+    res.custom = { ...error };
+  } else if (ctor === MtArgumentError) {
+    res.name = "MtArgumentError";
+  } else if (ctor === MtSecurityError) {
+    res.name = "MtSecurityError";
+  } else if (ctor === MtUnsupportedError) {
+    res.name = "MtUnsupportedError";
+  } else if (ctor === MtPeerNotFoundError) {
+    res.name = "MtPeerNotFoundError";
+  } else if (ctor === MtInvalidPeerTypeError) {
+    res.name = "MtInvalidPeerTypeError";
+  } else if (ctor === MtEmptyError) {
+    res.name = "MtEmptyError";
+  } else if (ctor instanceof MtcuteError) {
+    res.name = "MtcuteError";
+  }
+  return res;
+}
+function deserializeError(error) {
+  let err2;
+  switch (error.name) {
+    case "MtTypeAssertionError": {
+      const custom = error.custom;
+      err2 = new MtTypeAssertionError(custom.context, custom.expected, custom.actual);
+      break;
+    }
+    case "MtTimeoutError": {
+      const custom = error.custom;
+      err2 = new MtTimeoutError(custom.timeout);
+      break;
+    }
+    case "MtMessageNotFoundError": {
+      const custom = error.custom;
+      err2 = new MtMessageNotFoundError(custom.peerId, custom.messageId, custom.context);
+      break;
+    }
+    case "RpcError": {
+      const custom = error.custom;
+      err2 = new tl.RpcError(custom.code, custom.text);
+      err2.message = error.message;
+      for (const key in custom) {
+        if (key === "code" || key === "text") continue;
+        err2[key] = custom[key];
+      }
+      break;
+    }
+    case "MtArgumentError":
+      err2 = new MtArgumentError();
+      break;
+    case "MtSecurityError":
+      err2 = new MtSecurityError();
+      break;
+    case "MtUnsupportedError":
+      err2 = new MtUnsupportedError();
+      break;
+    case "MtPeerNotFoundError":
+      err2 = new MtPeerNotFoundError();
+      break;
+    case "MtInvalidPeerTypeError":
+      err2 = new MtInvalidPeerTypeError("", "");
+      err2.message = error.message;
+      break;
+    case "MtEmptyError":
+      err2 = new MtEmptyError();
+      break;
+    case "MtcuteError":
+      err2 = new MtcuteError();
+      break;
+    default:
+      err2 = new Error(error.message);
+  }
+  err2.stack = error.stack;
+  return err2;
+}
+export {
+  deserializeError,
+  serializeError
+};

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.cjs

@@ -0,0 +1,71 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const errors = require("./errors.cjs");
+const protocol = require("./protocol.cjs");
+class WorkerInvoker {
+  constructor(send) {
+    this.send = send;
+  }
+  _nextId = 0;
+  _pending = /* @__PURE__ */ new Map();
+  _invoke(target, method, args, isVoid, abortSignal) {
+    const id = this._nextId++;
+    this.send({
+      type: "invoke",
+      id,
+      target,
+      method,
+      args: protocol.serializeResult(args),
+      void: isVoid,
+      withAbort: Boolean(abortSignal)
+    });
+    abortSignal?.addEventListener("abort", () => {
+      this.send({
+        type: "abort",
+        id
+      });
+    });
+    if (!isVoid) {
+      const promise = new utils.Deferred();
+      this._pending.set(id, promise);
+      return promise.promise;
+    }
+  }
+  invoke(target, method, args) {
+    return this._invoke(target, method, args, false);
+  }
+  invokeVoid(target, method, args) {
+    this._invoke(target, method, args, true);
+  }
+  invokeWithAbort(target, method, args, abortSignal) {
+    if (abortSignal.aborted) return Promise.reject(abortSignal.reason);
+    return this._invoke(target, method, args, false, abortSignal);
+  }
+  handleResult(msg) {
+    const promise = this._pending.get(msg.id);
+    if (!promise) return;
+    if (msg.error) {
+      promise.reject(errors.deserializeError(msg.error));
+    } else {
+      promise.resolve(protocol.deserializeResult(msg.result));
+    }
+  }
+  makeBinder(target) {
+    return (method, isVoid = false) => {
+      let fn;
+      if (isVoid) {
+        fn = (...args) => this.invokeVoid(target, method, args);
+      } else {
+        fn = (...args) => this.invoke(target, method, args);
+      }
+      return fn;
+    };
+  }
+}
+exports.WorkerInvoker = WorkerInvoker;

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/invoker.js

@@ -0,0 +1,66 @@
+import { Deferred } from "@fuman/utils";
+import { deserializeError } from "./errors.js";
+import { serializeResult, deserializeResult } from "./protocol.js";
+class WorkerInvoker {
+  constructor(send) {
+    this.send = send;
+  }
+  _nextId = 0;
+  _pending = /* @__PURE__ */ new Map();
+  _invoke(target, method, args, isVoid, abortSignal) {
+    const id = this._nextId++;
+    this.send({
+      type: "invoke",
+      id,
+      target,
+      method,
+      args: serializeResult(args),
+      void: isVoid,
+      withAbort: Boolean(abortSignal)
+    });
+    abortSignal?.addEventListener("abort", () => {
+      this.send({
+        type: "abort",
+        id
+      });
+    });
+    if (!isVoid) {
+      const promise = new Deferred();
+      this._pending.set(id, promise);
+      return promise.promise;
+    }
+  }
+  invoke(target, method, args) {
+    return this._invoke(target, method, args, false);
+  }
+  invokeVoid(target, method, args) {
+    this._invoke(target, method, args, true);
+  }
+  invokeWithAbort(target, method, args, abortSignal) {
+    if (abortSignal.aborted) return Promise.reject(abortSignal.reason);
+    return this._invoke(target, method, args, false, abortSignal);
+  }
+  handleResult(msg) {
+    const promise = this._pending.get(msg.id);
+    if (!promise) return;
+    if (msg.error) {
+      promise.reject(deserializeError(msg.error));
+    } else {
+      promise.resolve(deserializeResult(msg.result));
+    }
+  }
+  makeBinder(target) {
+    return (method, isVoid = false) => {
+      let fn;
+      if (isVoid) {
+        fn = (...args) => this.invokeVoid(target, method, args);
+      } else {
+        fn = (...args) => this.invoke(target, method, args);
+      }
+      return fn;
+    };
+  }
+}
+export {
+  WorkerInvoker
+};

package/highlevel/worker/port.cjs

@@ -0,0 +1,141 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[mtcute-workspace] CommonJS support is deprecated and will be removed in 0.20.0. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[mtcute-workspace] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+const logger = require("../../utils/logger.cjs");
+const timers = require("../managers/timers.cjs");
+const peersIndex = require("../types/peers/peers-index.cjs");
+const appConfig = require("./app-config.cjs");
+const errors = require("./errors.cjs");
+const invoker = require("./invoker.cjs");
+const protocol = require("./protocol.cjs");
+const storage = require("./storage.cjs");
+class TelegramWorkerPort {
+  constructor(options) {
+    this.options = options;
+    this.log = new logger.LogManager("worker", options.platform);
+    this.platform = options.platform;
+    this._connection = this.connectToWorker(this.options.worker, this._onMessage);
+    this._invoker = new invoker.WorkerInvoker(this._connection[0]);
+    this.storage = new storage.TelegramStorageProxy(this._invoker);
+    this.appConfig = new appConfig.AppConfigManagerProxy(this._invoker);
+    const bind = this._invoker.makeBinder("client");
+    this.prepare = bind("prepare");
+    this._connect = bind("connect");
+    this.close = bind("close");
+    this.notifyLoggedIn = bind("notifyLoggedIn");
+    this.notifyLoggedOut = bind("notifyLoggedOut");
+    this.notifyChannelOpened = bind("notifyChannelOpened");
+    this.notifyChannelClosed = bind("notifyChannelClosed");
+    this.importSession = bind("importSession");
+    this.exportSession = bind("exportSession");
+    this.handleClientUpdate = bind("handleClientUpdate", true);
+    this.getApiCrenetials = bind("getApiCrenetials");
+    this.getPoolSize = bind("getPoolSize");
+    this.getPrimaryDcId = bind("getPrimaryDcId");
+    this.changePrimaryDc = bind("changePrimaryDc");
+    this.computeSrpParams = bind("computeSrpParams");
+    this.computeNewPasswordHash = bind("computeNewPasswordHash");
+    this.startUpdatesLoop = bind("startUpdatesLoop");
+    this.stopUpdatesLoop = bind("stopUpdatesLoop");
+    this.getMtprotoMessageId = bind("getMtprotoMessageId");
+    this.recreateDc = bind("recreateDc");
+    this.timers = new timers.TimersManager();
+    this.timers.onError((err) => this.onError.emit(utils.unknownToError(err)));
+  }
+  log;
+  platform;
+  _connection;
+  _invoker;
+  storage;
+  appConfig;
+  // todo: ideally timers should be handled on the worker side,
+  // but i'm not sure yet of the best way to handle multiple clients (e.g. in SharedWorker-s)
+  // (with one worker client it's not that big of a deal)
+  timers;
+  // bound methods
+  prepare;
+  _connect;
+  close;
+  notifyLoggedIn;
+  notifyLoggedOut;
+  notifyChannelOpened;
+  notifyChannelClosed;
+  importSession;
+  exportSession;
+  handleClientUpdate;
+  getApiCrenetials;
+  getPoolSize;
+  getPrimaryDcId;
+  changePrimaryDc;
+  computeSrpParams;
+  computeNewPasswordHash;
+  startUpdatesLoop;
+  stopUpdatesLoop;
+  getMtprotoMessageId;
+  recreateDc;
+  _abortController = new AbortController();
+  stopSignal = this._abortController.signal;
+  call(message, params) {
+    if (params?.abortSignal) {
+      const { abortSignal, ...rest } = params;
+      return this._invoker.invokeWithAbort("client", "call", [message, rest], abortSignal);
+    }
+    return this._invoker.invoke("client", "call", [message, params]);
+  }
+  onServerUpdate = new utils.Emitter();
+  onRawUpdate = new utils.Emitter();
+  onConnectionState = new utils.Emitter();
+  onError = new utils.Emitter();
+  _onMessage = (message) => {
+    switch (message.type) {
+      case "log":
+        this.log.handler(message.color, message.level, message.tag, message.fmt, message.args);
+        break;
+      case "server_update":
+        this.onServerUpdate.emit(protocol.deserializeResult(message.update));
+        break;
+      case "conn_state":
+        this.onConnectionState.emit(message.state);
+        break;
+      case "update": {
+        const peers = new peersIndex.PeersIndex(protocol.deserializeResult(message.users), protocol.deserializeResult(message.chats));
+        peers.hasMin = message.hasMin;
+        this.onRawUpdate.emit({ update: protocol.deserializeResult(message.update), peers });
+        break;
+      }
+      case "result":
+        this._invoker.handleResult(message);
+        break;
+      case "error":
+        this.onError.emit(errors.deserializeError(message.error));
+        break;
+      case "stop":
+        this._abortController.abort();
+        break;
+    }
+  };
+  _destroyed = false;
+  destroy(terminate = false) {
+    if (this._destroyed) return;
+    this.timers.destroy();
+    this._connection[1]();
+    this._destroyed = true;
+    if (terminate && "terminate" in this.options.worker) {
+      Promise.resolve(this.options.worker.terminate()).catch(() => {
+      });
+    }
+  }
+  invokeCustom(method, ...args) {
+    return this._invoker.invoke("custom", method, args);
+  }
+  async connect() {
+    await this._connect();
+    await this.storage.self.fetch();
+  }
+}
+exports.TelegramWorkerPort = TelegramWorkerPort;

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>;
+}

package/highlevel/worker/port.d.ts

@@ -1,22 +1,28 @@
 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 { ConnectionState, ITelegramClient, ServerUpdateHandler } from '../client.types.js';
-import { RawUpdateHandler } from '../updates/types.js';
+import { TimersManager } from '../managers/timers.js';
 import { AppConfigManagerProxy } from './app-config.js';
-import { ClientMessageHandler, SendFn, SomeWorker, WorkerCustomMethods } from './protocol.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'];
@@ -36,21 +42,16 @@ export declare abstract class TelegramWorkerPort<Custom extends WorkerCustomMeth
     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];
-    private _serverUpdatesHandler;
-    onServerUpdate(handler: ServerUpdateHandler): void;
-    getServerUpdateHandler(): ServerUpdateHandler;
-    private _errorHandler;
-    onError(handler: (err: unknown) => void): void;
-    emitError(err: unknown): void;
-    private _updateHandler;
-    onUpdate(handler: RawUpdateHandler): void;
-    private _connectionStateHandler;
-    onConnectionState(handler: (state: ConnectionState) => void): void;
+    onServerUpdate: Emitter<tl.TypeUpdates>;
+    onRawUpdate: Emitter<RawUpdateInfo>;
+    onConnectionState: Emitter<ConnectionState>;
+    onError: Emitter<Error>;
     private _onMessage;
     private _destroyed;
     destroy(terminate?: boolean): void;