@mtcute/node 0.16.7 → 0.16.13

package/index.js

@@ -1 +1,410 @@
-export * from './esm/index.js'
+import { createInterface } from "node:readline";
+import { BaseTelegramClient as BaseTelegramClient$1, TelegramClient as TelegramClient$1 } from "@mtcute/core/client.js";
+import { setPlatform } from "@mtcute/core/platform.js";
+import * as os from "node:os";
+import { createReadStream, ReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { Readable } from "node:stream";
+import { nodeStreamToWeb } from "./chunks/es/CKso6cAV.js";
+import { downloadToFile, downloadAsNodeStream } from "./chunks/es/CnOjjhdK.js";
+import { BaseSqliteStorageDriver, BaseSqliteStorage, TransportState, MtcuteError, IntermediatePacketCodec } from "@mtcute/core";
+export * from "@mtcute/core";
+import sqlite3 from "better-sqlite3";
+import { NodeCryptoProvider } from "./chunks/es/HZgHrOPU.js";
+import EventEmitter from "node:events";
+import { connect } from "node:net";
+import { parentPort, Worker } from "node:worker_threads";
+import { TelegramWorker as TelegramWorker$1, TelegramWorkerPort as TelegramWorkerPort$1 } from "@mtcute/core/worker.js";
+export * from "@mtcute/html-parser";
+export * from "@mtcute/markdown-parser";
+async function normalizeFile(file) {
+  if (typeof file === "string") {
+    file = createReadStream(file);
+  }
+  if (file instanceof ReadStream) {
+    const fileName = basename(file.path.toString());
+    const fileSize = await stat(file.path.toString()).then((stat2) => stat2.size);
+    return {
+      file: nodeStreamToWeb(file),
+      fileName,
+      fileSize
+    };
+  }
+  if (file instanceof Readable) {
+    return {
+      file: nodeStreamToWeb(file)
+    };
+  }
+  return null;
+}
+let installed = false;
+let handled = false;
+const callbacks = /* @__PURE__ */ new Set();
+const myHandlers = /* @__PURE__ */ new Map();
+function register(shouldManuallyExit, signal, event) {
+  function eventHandler() {
+    if (handled) {
+      return;
+    }
+    handled = true;
+    for (const callback of callbacks) {
+      callback();
+    }
+    for (const [event2, handler] of myHandlers) {
+      process.off(event2, handler);
+    }
+    if (shouldManuallyExit) {
+      process.kill(process.pid, signal);
+    }
+  }
+  process.on(event, eventHandler);
+  myHandlers.set(event, eventHandler);
+}
+function beforeExit(fn) {
+  if (typeof process === "undefined") return () => {
+  };
+  if (!installed) {
+    installed = true;
+    register(true, 0, "beforeExit");
+    register(true, 2, "SIGINT");
+    register(true, 15, "SIGTERM");
+    register(false, 15, "exit");
+  }
+  callbacks.add(fn);
+  return () => {
+    callbacks.delete(fn);
+  };
+}
+const isTty = typeof process === "object" && Boolean(process.stdout?.isTTY);
+const BASE_FORMAT = isTty ? "%s [%s] [%s%s\x1B[0m] " : "%s [%s] [%s] ";
+const LEVEL_NAMES = isTty ? [
+  "",
+  // OFF
+  "\x1B[31mERR\x1B[0m",
+  "\x1B[33mWRN\x1B[0m",
+  "\x1B[34mINF\x1B[0m",
+  "\x1B[36mDBG\x1B[0m",
+  "\x1B[35mVRB\x1B[0m"
+] : [
+  "",
+  // OFF
+  "ERR",
+  "WRN",
+  "INF",
+  "DBG",
+  "VRB"
+];
+const TAG_COLORS = [6, 2, 3, 4, 5, 1].map((i) => `\x1B[3${i};1m`);
+const defaultLoggingHandler = isTty ? (color, level, tag, fmt, args) => {
+  console.log(BASE_FORMAT + fmt, (/* @__PURE__ */ new Date()).toISOString(), LEVEL_NAMES[level], TAG_COLORS[color], tag, ...args);
+} : (color, level, tag, fmt, args) => {
+  console.log(BASE_FORMAT + fmt, (/* @__PURE__ */ new Date()).toISOString(), LEVEL_NAMES[level], tag, ...args);
+};
+const BUFFER_BASE64_URL_AVAILABLE = typeof Buffer.isEncoding === "function" && Buffer.isEncoding("base64url");
+const toBuffer = (buf) => Buffer.from(buf.buffer, buf.byteOffset, buf.byteLength);
+class NodePlatform {
+  getDeviceModel() {
+    return `Node.js/${process.version} (${os.type()} ${os.arch()})`;
+  }
+  getDefaultLogLevel() {
+    const envLogLevel = Number.parseInt(process.env.MTCUTE_LOG_LEVEL ?? "");
+    if (!Number.isNaN(envLogLevel)) {
+      return envLogLevel;
+    }
+    return null;
+  }
+  // ITlPlatform
+  utf8ByteLength(str) {
+    return Buffer.byteLength(str, "utf8");
+  }
+  utf8Encode(str) {
+    return Buffer.from(str, "utf8");
+  }
+  utf8Decode(buf) {
+    return toBuffer(buf).toString("utf8");
+  }
+  hexEncode(buf) {
+    return toBuffer(buf).toString("hex");
+  }
+  hexDecode(str) {
+    return Buffer.from(str, "hex");
+  }
+  base64Encode(buf, url = false) {
+    const nodeBuffer = toBuffer(buf);
+    if (url && BUFFER_BASE64_URL_AVAILABLE) return nodeBuffer.toString("base64url");
+    const str = nodeBuffer.toString("base64");
+    if (url) return str.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    return str;
+  }
+  base64Decode(string, url = false) {
+    if (url && BUFFER_BASE64_URL_AVAILABLE) {
+      return Buffer.from(string, "base64url");
+    }
+    if (url) {
+      string = string.replace(/-/g, "+").replace(/_/g, "/");
+      while (string.length % 4) string += "=";
+    }
+    return Buffer.from(string, "base64");
+  }
+}
+NodePlatform.prototype.log = defaultLoggingHandler;
+NodePlatform.prototype.beforeExit = beforeExit;
+NodePlatform.prototype.normalizeFile = normalizeFile;
+class SqliteStorageDriver extends BaseSqliteStorageDriver {
+  constructor(filename = ":memory:", params) {
+    super();
+    this.filename = filename;
+    this.params = params;
+  }
+  _createDatabase() {
+    const db = sqlite3(this.filename, {
+      ...this.params?.options,
+      verbose: this._log.mgr.level >= 5 ? this._log.verbose : void 0
+    });
+    if (!this.params?.disableWal) {
+      db.pragma("journal_mode = WAL");
+    }
+    return db;
+  }
+}
+class SqliteStorage extends BaseSqliteStorage {
+  constructor(filename = ":memory:", params) {
+    super(new SqliteStorageDriver(filename, params));
+    this.filename = filename;
+    this.params = params;
+  }
+}
+class BaseTcpTransport extends EventEmitter {
+  _currentDc = null;
+  _state = TransportState.Idle;
+  _socket = null;
+  _crypto;
+  log;
+  packetCodecInitialized = false;
+  _updateLogPrefix() {
+    if (this._currentDc) {
+      this.log.prefix = `[TCP:${this._currentDc.ipAddress}:${this._currentDc.port}] `;
+    } else {
+      this.log.prefix = "[TCP:disconnected] ";
+    }
+  }
+  setup(crypto, log) {
+    this._crypto = crypto;
+    this.log = log.create("tcp");
+    this._updateLogPrefix();
+  }
+  state() {
+    return this._state;
+  }
+  currentDc() {
+    return this._currentDc;
+  }
+  // eslint-disable-next-line unused-imports/no-unused-vars
+  connect(dc, testMode) {
+    if (this._state !== TransportState.Idle) {
+      throw new MtcuteError("Transport is not IDLE");
+    }
+    if (!this.packetCodecInitialized) {
+      this._packetCodec.setup?.(this._crypto, this.log);
+      this._packetCodec.on("error", (err) => this.emit("error", err));
+      this._packetCodec.on("packet", (buf) => this.emit("message", buf));
+      this.packetCodecInitialized = true;
+    }
+    this._state = TransportState.Connecting;
+    this._currentDc = dc;
+    this._updateLogPrefix();
+    this.log.debug("connecting to %j", dc);
+    this._socket = connect(dc.port, dc.ipAddress, this.handleConnect.bind(this));
+    this._socket.on("data", (data) => {
+      this._packetCodec.feed(data);
+    });
+    this._socket.on("error", this.handleError.bind(this));
+    this._socket.on("close", this.close.bind(this));
+  }
+  close() {
+    if (this._state === TransportState.Idle) return;
+    this.log.info("connection closed");
+    this._state = TransportState.Idle;
+    this._socket.removeAllListeners();
+    this._socket.destroy();
+    this._socket = null;
+    this._currentDc = null;
+    this._packetCodec.reset();
+    this.emit("close");
+  }
+  handleError(error) {
+    this.log.error("error: %s", error.stack);
+    if (this.listenerCount("error") > 0) {
+      this.emit("error", error);
+    }
+  }
+  handleConnect() {
+    this.log.info("connected");
+    Promise.resolve(this._packetCodec.tag()).then((initialMessage) => {
+      if (initialMessage.length) {
+        this._socket.write(initialMessage, (err) => {
+          if (err) {
+            this.log.error("failed to write initial message: %s", err.stack);
+            this.emit("error");
+            this.close();
+          } else {
+            this._state = TransportState.Ready;
+            this.emit("ready");
+          }
+        });
+      } else {
+        this._state = TransportState.Ready;
+        this.emit("ready");
+      }
+    }).catch((err) => this.emit("error", err));
+  }
+  async send(bytes) {
+    const framed = await this._packetCodec.encode(bytes);
+    if (this._state !== TransportState.Ready) {
+      throw new MtcuteError("Transport is not READY");
+    }
+    return new Promise((resolve, reject) => {
+      this._socket.write(framed, (error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+}
+class TcpTransport extends BaseTcpTransport {
+  _packetCodec = new IntermediatePacketCodec();
+}
+let nativeCrypto;
+try {
+  nativeCrypto = (await import("@mtcute/crypto-node")).NodeNativeCryptoProvider;
+} catch {
+}
+class BaseTelegramClient extends BaseTelegramClient$1 {
+  constructor(opts) {
+    if (!opts.platformless) setPlatform(new NodePlatform());
+    super({
+      // eslint-disable-next-line
+      crypto: nativeCrypto ? new nativeCrypto() : new NodeCryptoProvider(),
+      transport: () => new TcpTransport(),
+      ...opts,
+      storage: typeof opts.storage === "string" ? new SqliteStorage(opts.storage) : opts.storage ?? new SqliteStorage("client.session")
+    });
+  }
+}
+class TelegramClient extends TelegramClient$1 {
+  constructor(opts) {
+    if ("client" in opts) {
+      super(opts);
+      return;
+    }
+    super({
+      client: new BaseTelegramClient(opts),
+      disableUpdates: opts.disableUpdates,
+      skipConversationUpdates: opts.skipConversationUpdates,
+      updates: opts.updates
+    });
+  }
+  _rl;
+  /**
+   * Tiny wrapper over Node `readline` package
+   * for simpler user input for `.start()` method.
+   *
+   * Associated `readline` interface is closed
+   * after `start()` returns, or with the client.
+   *
+   * @param text  Text of the question
+   */
+  input(text) {
+    if (!this._rl) {
+      this._rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+    }
+    return new Promise((res) => this._rl?.question(text, res));
+  }
+  close() {
+    this._rl?.close();
+    return super.close();
+  }
+  start(params = {}) {
+    if (!params.botToken) {
+      if (!params.phone) params.phone = () => this.input("phone > ");
+      if (!params.code) params.code = () => this.input("code > ");
+      if (!params.password) {
+        params.password = () => this.input("2fa password > ");
+      }
+    }
+    return super.start(params).then((user) => {
+      if (this._rl) {
+        this._rl.close();
+        delete this._rl;
+      }
+      return user;
+    });
+  }
+  run(params, then) {
+    if (typeof params === "function") {
+      then = params;
+      params = {};
+    }
+    this.start(params).then(then).catch((err) => this.emitError(err));
+  }
+  downloadToFile(filename, location, params) {
+    return downloadToFile(this, filename, location, params);
+  }
+  downloadAsNodeStream(location, params) {
+    return downloadAsNodeStream(this, location, params);
+  }
+}
+let _registered = false;
+class TelegramWorker extends TelegramWorker$1 {
+  registerWorker(handler) {
+    if (!parentPort) {
+      throw new Error("TelegramWorker must be created from a worker thread");
+    }
+    if (_registered) {
+      throw new Error("TelegramWorker must be created only once");
+    }
+    _registered = true;
+    const port = parentPort;
+    const respond = port.postMessage.bind(port);
+    parentPort.on("message", (message) => handler(message, respond));
+    return respond;
+  }
+}
+class TelegramWorkerPort extends TelegramWorkerPort$1 {
+  constructor(options) {
+    setPlatform(new NodePlatform());
+    super(options);
+    this.options = options;
+  }
+  connectToWorker(worker, handler) {
+    if (!(worker instanceof Worker)) {
+      throw new TypeError("Only worker_threads are supported");
+    }
+    const send = worker.postMessage.bind(worker);
+    worker.on("message", handler);
+    return [
+      send,
+      () => {
+        worker.off("message", handler);
+      }
+    ];
+  }
+}
+export {
+  BaseTcpTransport,
+  BaseTelegramClient,
+  NodePlatform,
+  SqliteStorage,
+  SqliteStorageDriver,
+  TcpTransport,
+  TelegramClient,
+  TelegramWorker,
+  TelegramWorkerPort
+};

package/{cjs/methods → methods}/download-file.d.ts

@@ -1,4 +1,4 @@
-import type { FileDownloadLocation, FileDownloadParameters, ITelegramClient } from '@mtcute/core';
+import { FileDownloadLocation, FileDownloadParameters, ITelegramClient } from '@mtcute/core';
 /**
  * Download a remote file to a local file (only for NodeJS).
  * Promise will resolve once the download is complete.

package/{esm/methods → methods}/download-node-stream.d.ts

@@ -1,5 +1,5 @@
-import type { Readable } from 'node:stream';
-import type { FileDownloadLocation, FileDownloadParameters, ITelegramClient } from '@mtcute/core';
+import { Readable } from 'node:stream';
+import { FileDownloadLocation, FileDownloadParameters, ITelegramClient } from '@mtcute/core';
 /**
  * Download a remote file as a Node.js Readable stream.
  *

package/methods.cjs

@@ -0,0 +1,17 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/node] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/node] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const downloadNodeStream = require("./chunks/cjs/BpvQ752Q.js");
+const methods_js = require("@mtcute/core/methods.js");
+exports.downloadAsNodeStream = downloadNodeStream.downloadAsNodeStream;
+exports.downloadToFile = downloadNodeStream.downloadToFile;
+Object.keys(methods_js).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => methods_js[k]
+  });
+});

package/methods.d.ts

@@ -1 +1,3 @@
-export * from './esm/methods.js'
+export { downloadToFile } from './methods/download-file.js';
+export { downloadAsNodeStream } from './methods/download-node-stream.js';
+export * from '@mtcute/core/methods.js';

package/methods.js

@@ -1 +1,6 @@
-export * from './esm/methods.js'
+import { downloadAsNodeStream, downloadToFile } from "./chunks/es/CnOjjhdK.js";
+export * from "@mtcute/core/methods.js";
+export {
+  downloadAsNodeStream,
+  downloadToFile
+};

package/package.json

@@ -1,38 +1,54 @@
 {
-  "name": "@mtcute/node",
-  "type": "module",
-  "version": "0.16.7",
-  "description": "Meta-package for Node.js",
-  "author": "alina sireneva <alina@tei.su>",
-  "license": "MIT",
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "import": "./esm/index.js",
-      "require": "./cjs/index.js"
+    "name": "@mtcute/node",
+    "type": "module",
+    "version": "0.16.13",
+    "description": "Meta-package for Node.js",
+    "author": "alina sireneva <alina@tei.su>",
+    "license": "MIT",
+    "sideEffects": false,
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        },
+        "./utils.js": {
+            "import": {
+                "types": "./utils.d.ts",
+                "default": "./utils.js"
+            },
+            "require": {
+                "types": "./utils.d.cts",
+                "default": "./utils.cjs"
+            }
+        },
+        "./methods.js": {
+            "import": {
+                "types": "./methods.d.ts",
+                "default": "./methods.js"
+            },
+            "require": {
+                "types": "./methods.d.cts",
+                "default": "./methods.cjs"
+            }
+        }
     },
-    "./utils.js": {
-      "import": "./esm/utils.js",
-      "require": "./cjs/utils.js"
+    "scripts": {},
+    "dependencies": {
+        "@mtcute/core": "^0.16.13",
+        "@mtcute/html-parser": "^0.16.9",
+        "@mtcute/markdown-parser": "^0.16.9",
+        "@mtcute/wasm": "^0.16.11",
+        "better-sqlite3": "11.3.0"
     },
-    "./methods.js": {
-      "import": "./esm/methods.js",
-      "require": "./cjs/methods.js"
+    "homepage": "https://mtcute.dev",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/mtcute/mtcute"
     }
-  },
-  "scripts": {},
-  "dependencies": {
-    "@mtcute/core": "^0.16.7",
-    "@mtcute/html-parser": "^0.16.7",
-    "@mtcute/markdown-parser": "^0.16.7",
-    "@mtcute/wasm": "^0.16.7",
-    "better-sqlite3": "9.5.0"
-  },
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
-  "homepage": "https://mtcute.dev",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/mtcute/mtcute"
-  }
 }

package/{esm/sqlite → sqlite}/driver.d.ts

@@ -1,6 +1,5 @@
-import type { Options } from 'better-sqlite3';
-import type { ISqliteDatabase } from '@mtcute/core';
-import { BaseSqliteStorageDriver } from '@mtcute/core';
+import { Options } from 'better-sqlite3';
+import { ISqliteDatabase, BaseSqliteStorageDriver } from '@mtcute/core';
 export interface SqliteStorageDriverOptions {
     /**
      * By default, WAL mode is enabled, which

package/{esm/sqlite → sqlite}/index.d.ts

@@ -1,5 +1,5 @@
 import { BaseSqliteStorage } from '@mtcute/core';
-import type { SqliteStorageDriverOptions } from './driver.js';
+import { SqliteStorageDriverOptions } from './driver.js';
 export { SqliteStorageDriver } from './driver.js';
 export declare class SqliteStorage extends BaseSqliteStorage {
     readonly filename: string;

package/sqlite/sqlite.test.d.ts

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

package/{cjs/utils → utils}/crypto.d.ts

@@ -1,5 +1,4 @@
-import type { IAesCtr, ICryptoProvider, IEncryptionScheme } from '@mtcute/core/utils.js';
-import { BaseCryptoProvider } from '@mtcute/core/utils.js';
+import { IAesCtr, ICryptoProvider, IEncryptionScheme, BaseCryptoProvider } from '@mtcute/core/utils.js';
 export declare abstract class BaseNodeCryptoProvider extends BaseCryptoProvider {
     createAesCtr(key: Uint8Array, iv: Uint8Array): IAesCtr;
     pbkdf2(password: Uint8Array, salt: Uint8Array, iterations: number, keylen?: number, algo?: string): Promise<Uint8Array>;

package/utils/crypto.test.d.ts

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

package/{cjs/utils → utils}/normalize-file.d.ts

@@ -1,4 +1,4 @@
-import type { UploadFileLike } from '@mtcute/core';
+import { UploadFileLike } from '@mtcute/core';
 export declare function normalizeFile(file: UploadFileLike): Promise<{
     file: UploadFileLike;
     fileName?: string | undefined;

package/utils/stream-utils.test.d.ts

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

package/{cjs/utils → utils}/tcp.d.ts

@@ -1,8 +1,7 @@
-import EventEmitter from 'node:events';
-import type { Socket } from 'node:net';
-import type { IPacketCodec, ITelegramTransport } from '@mtcute/core';
-import { IntermediatePacketCodec, TransportState } from '@mtcute/core';
-import type { BasicDcOption, ICryptoProvider, Logger } from '@mtcute/core/utils.js';
+import { default as EventEmitter } from 'node:events';
+import { Socket } from 'node:net';
+import { IPacketCodec, ITelegramTransport, IntermediatePacketCodec, TransportState } from '@mtcute/core';
+import { BasicDcOption, ICryptoProvider, Logger } from '@mtcute/core/utils.js';
 /**
  * Base for TCP transports.
  * Subclasses must provide packet codec in `_packetCodec` property

package/utils/tcp.test.d.ts

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

package/utils.cjs

@@ -0,0 +1,20 @@
+if (typeof globalThis !== "undefined" && !globalThis._MTCUTE_CJS_DEPRECATION_WARNED) {
+  globalThis._MTCUTE_CJS_DEPRECATION_WARNED = true;
+  console.warn("[@mtcute/node] CommonJS support is deprecated and will be removed soon. Please consider switching to ESM, it's " + (/* @__PURE__ */ new Date()).getFullYear() + " already.");
+  console.warn("[@mtcute/node] Learn more about switching to ESM: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c");
+}
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const crypto = require("./chunks/cjs/D7i-4e0W.js");
+const streamUtils = require("./chunks/cjs/HP2yqAk_.js");
+const utils_js = require("@mtcute/core/utils.js");
+exports.BaseNodeCryptoProvider = crypto.BaseNodeCryptoProvider;
+exports.NodeCryptoProvider = crypto.NodeCryptoProvider;
+exports.nodeStreamToWeb = streamUtils.nodeStreamToWeb;
+exports.webStreamToNode = streamUtils.webStreamToNode;
+Object.keys(utils_js).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => utils_js[k]
+  });
+});

package/utils.d.ts

@@ -1 +1,3 @@
-export * from './esm/utils.js'
+export * from './utils/crypto.js';
+export * from './utils/stream-utils.js';
+export * from '@mtcute/core/utils.js';

package/utils.js

@@ -1 +1,9 @@
-export * from './esm/utils.js'
+import { BaseNodeCryptoProvider, NodeCryptoProvider } from "./chunks/es/HZgHrOPU.js";
+import { nodeStreamToWeb, webStreamToNode } from "./chunks/es/CKso6cAV.js";
+export * from "@mtcute/core/utils.js";
+export {
+  BaseNodeCryptoProvider,
+  NodeCryptoProvider,
+  nodeStreamToWeb,
+  webStreamToNode
+};

package/{cjs/worker.d.ts → worker.d.ts}

@@ -1,5 +1,4 @@
-import type { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, TelegramWorkerPortOptions, WorkerCustomMethods, WorkerMessageHandler } from '@mtcute/core/worker.js';
-import { TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
+import { ClientMessageHandler, RespondFn, SendFn, SomeWorker, TelegramWorkerOptions, TelegramWorkerPortOptions, WorkerCustomMethods, WorkerMessageHandler, TelegramWorker as TelegramWorkerBase, TelegramWorkerPort as TelegramWorkerPortBase } from '@mtcute/core/worker.js';
 export type { TelegramWorkerOptions, TelegramWorkerPortOptions, WorkerCustomMethods };
 export declare class TelegramWorker<T extends WorkerCustomMethods> extends TelegramWorkerBase<T> {
     registerWorker(handler: WorkerMessageHandler): RespondFn;