@mtcute/dispatcher 0.17.2 → 0.18.0

package/dispatcher.cjs

@@ -0,0 +1,860 @@
+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 core = require("@mtcute/core");
+const parse = require("./context/parse.cjs");
+const sceneTransition = require("./context/scene-transition.cjs");
+const service = require("./state/service.cjs");
+const key = require("./state/key.cjs");
+const updateState = require("./state/update-state.cjs");
+class Dispatcher {
+  _groups = /* @__PURE__ */ new Map();
+  _groupsOrder = [];
+  _client;
+  _parent;
+  _children = [];
+  _scenes;
+  _scene;
+  _sceneScoped;
+  _storage;
+  _stateKeyDelegate;
+  _customStateKeyDelegate;
+  _customStorage;
+  _deps = {};
+  _errorHandler;
+  _preUpdateHandler;
+  _postUpdateHandler;
+  _sceneTransitionHandler;
+  constructor(client, params) {
+    this.dispatchRawUpdate = this.dispatchRawUpdate.bind(this);
+    this.dispatchUpdate = this.dispatchUpdate.bind(this);
+    let { storage, key: key$1, sceneName } = params ?? {};
+    if (client) {
+      this.bindToClient(client);
+      if (storage) {
+        this._storage = new service.StateService(storage);
+        this._stateKeyDelegate = key$1 ?? key.defaultStateKeyDelegate;
+      }
+    } else {
+      if (storage) {
+        this._customStorage = new service.StateService(storage);
+      }
+      if (key$1) {
+        this._customStateKeyDelegate = key$1;
+      }
+      if (sceneName) {
+        if (sceneName[0] === "$") {
+          throw new core.MtArgumentError("Scene name cannot start with $");
+        }
+        this._scene = sceneName;
+      }
+    }
+  }
+  static for(client, params) {
+    return new Dispatcher(client, params);
+  }
+  /**
+   * Create a new child dispatcher.
+   */
+  static child(params) {
+    return new Dispatcher(void 0, params);
+  }
+  /**
+   * Create a new scene dispatcher
+   */
+  static scene(name, params) {
+    return new Dispatcher(void 0, { sceneName: name, ...params });
+  }
+  /** For scene dispatchers, name of the scene */
+  get sceneName() {
+    return this._scene;
+  }
+  inject(name, value) {
+    if (this._parent) {
+      throw new core.MtArgumentError("Cannot inject dependencies to child dispatchers");
+    }
+    if (typeof name === "object") {
+      for (const [k, v] of Object.entries(name)) {
+        this._deps[k] = v;
+      }
+    } else {
+      this._deps[name] = value;
+    }
+  }
+  /**
+   * Get the dependencies injected into this dispatcher.
+   */
+  get deps() {
+    return this._deps;
+  }
+  /**
+   * Bind the dispatcher to the client.
+   * Called by the constructor automatically if
+   * `client` was passed.
+   *
+   * Dispatcher also uses bound client to throw errors
+   */
+  bindToClient(client) {
+    client.onUpdate.add(this.dispatchUpdate);
+    client.onRawUpdate.add(this.dispatchRawUpdate);
+    this._client = client;
+  }
+  /**
+   * Unbind a dispatcher from the client.
+   */
+  unbind() {
+    if (this._client) {
+      this._client.onUpdate.remove(this.dispatchUpdate);
+      this._client.onRawUpdate.remove(this.dispatchRawUpdate);
+      this._client = void 0;
+    }
+  }
+  /**
+   * Destroy the dispatcher and all its children.
+   *
+   * When destroying, all the registered handlers are removed,
+   * and the underlying storage is freed.
+   */
+  async destroy() {
+    if (this._parent && this._customStorage) {
+      await this._customStorage.destroy();
+    } else if (!this._parent && this._storage) {
+      await this._storage.destroy();
+    }
+    this.removeUpdateHandler("all");
+    for (const child of this._children) {
+      await child.destroy();
+    }
+    for (const scene of this._scenes?.values() ?? []) {
+      await scene.destroy();
+    }
+  }
+  /**
+   * Process a raw update with this dispatcher.
+   * Calling this method without bound client will not work.
+   *
+   * Under the hood asynchronously calls {@link dispatchRawUpdateNow}
+   * with error handler set to client's one.
+   *
+   * @param update  Update to process
+   * @param peers Peers index
+   */
+  dispatchRawUpdate({ update, peers }) {
+    if (!this._client) return;
+    this.dispatchRawUpdateNow(update, peers).catch((err) => this._client.onError.emit(utils.unknownToError(err)));
+  }
+  /**
+   * Process a raw update right now in the current stack.
+   *
+   * Unlike {@link dispatchRawUpdate}, this does not schedule
+   * the update to be dispatched, but dispatches it immediately,
+   * and after `await`ing this method you can be certain that the update
+   * was fully processed by all the registered handlers, including children.
+   *
+   * @param update  Update to process
+   * @param peers  Peers map
+   * @returns  Whether the update was handled
+   */
+  async dispatchRawUpdateNow(update, peers) {
+    if (!this._client) return false;
+    let handled = false;
+    outer: for (const grp of this._groupsOrder) {
+      const group = this._groups.get(grp);
+      if (group.has("raw")) {
+        const handlers = group.get("raw");
+        for (const h of handlers) {
+          let result;
+          if (!h.check || await h.check(this._client, update, peers)) {
+            result = await h.callback(this._client, update, peers);
+            handled = true;
+          } else {
+            continue;
+          }
+          switch (result) {
+            case "continue":
+              continue;
+            case "stop":
+              break outer;
+            case "stop-children":
+              return handled;
+          }
+          break;
+        }
+      }
+    }
+    for (const child of this._children) {
+      const childHandled = await child.dispatchRawUpdateNow(update, peers);
+      handled ||= childHandled;
+    }
+    return handled;
+  }
+  /**
+   * Process an update with this dispatcher.
+   * Calling this method without bound client will not work.
+   *
+   * Under the hood asynchronously calls {@link dispatchUpdateNow}
+   * with error handler set to client's one.
+   *
+   * @param update  Update to process
+   */
+  dispatchUpdate(update) {
+    if (!this._client) return;
+    this.dispatchUpdateNow(update).catch((err) => this._client.onError.emit(utils.unknownToError(err)));
+  }
+  /**
+   * Process an update right now in the current stack.
+   *
+   * Unlike {@link dispatchUpdate}, this does not schedule
+   * the update to be dispatched, but dispatches it immediately,
+   * and after `await`ing this method you can be certain that the update
+   * was fully processed by all the registered handlers, including children.
+   *
+   * @param update  Update to process
+   * @returns  Whether the update was handled
+   */
+  async dispatchUpdateNow(update) {
+    return this._dispatchUpdateNowImpl(update);
+  }
+  async _dispatchUpdateNowImpl(update, parsedState, parsedScene, forceScene, parsedContext) {
+    if (!this._client) return false;
+    if (parsedScene === void 0) {
+      if (this._storage && this._scenes && (update.name === "new_message" || update.name === "edit_message" || update.name === "callback_query" || update.name === "message_group" || update.name === "new_business_message" || update.name === "edit_business_message" || update.name === "business_message_group")) {
+        if (!parsedContext) parsedContext = parse._parsedUpdateToContext(this._client, update);
+        const key2 = await this._stateKeyDelegate(parsedContext);
+        if (key2) {
+          parsedScene = await this._storage.getCurrentScene(key2);
+        } else {
+          parsedScene = null;
+        }
+      } else {
+        parsedScene = null;
+      }
+    }
+    if (!forceScene && parsedScene !== null) {
+      if (this._scene) {
+        if (this._scene !== parsedScene) {
+          return false;
+        }
+      } else {
+        if (!this._scenes || !this._scenes.has(parsedScene)) {
+          return false;
+        }
+        return this._scenes.get(parsedScene)._dispatchUpdateNowImpl(update, parsedState, parsedScene, true);
+      }
+    }
+    if (parsedState === void 0) {
+      if (this._storage && (update.name === "new_message" || update.name === "edit_message" || update.name === "callback_query" || update.name === "message_group" || update.name === "new_business_message" || update.name === "edit_business_message" || update.name === "business_message_group")) {
+        if (!parsedContext) parsedContext = parse._parsedUpdateToContext(this._client, update);
+        const key2 = await this._stateKeyDelegate(parsedContext);
+        if (key2) {
+          let customKey;
+          if (!this._customStateKeyDelegate || (customKey = await this._customStateKeyDelegate(parsedContext))) {
+            parsedState = new updateState.UpdateState(
+              this._storage,
+              key2,
+              this._scene ?? null,
+              this._sceneScoped,
+              this._customStorage,
+              customKey
+            );
+          }
+        } else {
+          parsedState = null;
+        }
+      } else {
+        parsedState = null;
+      }
+    }
+    let shouldDispatch = true;
+    let shouldDispatchChildren = true;
+    let handled = false;
+    switch (await this._preUpdateHandler?.(update, parsedState)) {
+      case "stop":
+        shouldDispatch = false;
+        break;
+      case "stop-children":
+        return false;
+    }
+    if (shouldDispatch) {
+      outer: for (const grp of this._groupsOrder) {
+        const group = this._groups.get(grp);
+        if (group.has(update.name)) {
+          const handlers = group.get(update.name);
+          try {
+            for (const h of handlers) {
+              let result;
+              if (!parsedContext) parsedContext = parse._parsedUpdateToContext(this._client, update);
+              if (!h.check || await h.check(parsedContext, parsedState)) {
+                result = await h.callback(parsedContext, parsedState);
+                handled = true;
+              } else {
+                continue;
+              }
+              if (parsedState && this._scenes) {
+                const newScene = parsedState.scene;
+                if (parsedScene !== newScene) {
+                  const nextDp = newScene ? this._scenes.get(newScene) : this._parent;
+                  if (!nextDp) {
+                    throw new core.MtArgumentError(`Scene ${newScene} not found`);
+                  }
+                  if (nextDp._sceneTransitionHandler) {
+                    const transition = new sceneTransition.SceneTransitionContext(parsedScene, parsedContext);
+                    const transitionResult = await nextDp._sceneTransitionHandler?.(
+                      transition,
+                      parsedState
+                    );
+                    switch (transitionResult) {
+                      case "stop":
+                        return true;
+                      case "continue":
+                        continue;
+                      case "scene": {
+                        const scene = parsedState.scene;
+                        const dp = scene ? nextDp._scenes.get(scene) : nextDp._parent;
+                        return dp._dispatchUpdateNowImpl(update, void 0, scene, true);
+                      }
+                    }
+                  }
+                }
+              }
+              switch (result) {
+                case "continue":
+                  continue;
+                case "stop":
+                  break outer;
+                case "stop-children":
+                  shouldDispatchChildren = false;
+                  break outer;
+                case "scene": {
+                  if (!parsedState) {
+                    throw new core.MtArgumentError("Cannot use ToScene without state");
+                  }
+                  const scene = parsedState.scene;
+                  const dp = scene ? this._scenes.get(scene) : this._parent;
+                  return dp._dispatchUpdateNowImpl(update, void 0, scene, true);
+                }
+              }
+              break;
+            }
+          } catch (e) {
+            if (this._errorHandler) {
+              const handled2 = await this._errorHandler(e, update, parsedState);
+              if (!handled2) throw e;
+            } else {
+              throw e;
+            }
+          }
+        }
+      }
+    }
+    if (shouldDispatchChildren) {
+      for (const child of this._children) {
+        const childHandled = await child._dispatchUpdateNowImpl(update);
+        handled ||= childHandled;
+      }
+    }
+    await this._postUpdateHandler?.(handled, update, parsedState);
+    return handled;
+  }
+  /**
+   * Add an update handler to a given handlers group
+   *
+   * @param handler  Update handler
+   * @param group  Handler group index
+   */
+  addUpdateHandler(handler, group = 0) {
+    if (!this._groups.has(group)) {
+      this._groups.set(group, /* @__PURE__ */ new Map());
+      this._groupsOrder.push(group);
+      this._groupsOrder.sort((a, b) => a - b);
+    }
+    if (!this._groups.get(group).has(handler.name)) {
+      this._groups.get(group).set(handler.name, []);
+    }
+    this._groups.get(group).get(handler.name).push(handler);
+  }
+  /**
+   * Remove an update handler (or handlers) from a given
+   * handler group.
+   *
+   * @param handler  Update handler to remove, its name or `'all'` to remove all
+   * @param group  Handler group index (null to affect all groups)
+   */
+  removeUpdateHandler(handler, group = 0) {
+    if (group !== null && !this._groups.has(group)) {
+      return;
+    }
+    if (typeof handler === "string") {
+      if (handler === "all") {
+        if (group === null) {
+          this._groups = /* @__PURE__ */ new Map();
+        } else {
+          this._groups.delete(group);
+        }
+      } else if (group !== null) {
+        this._groups.get(group).delete(handler);
+      }
+      return;
+    }
+    if (group === null) return;
+    if (!this._groups.get(group).has(handler.name)) {
+      return;
+    }
+    const idx = this._groups.get(group).get(handler.name).indexOf(handler);
+    if (idx > -1) {
+      this._groups.get(group).get(handler.name).splice(idx, 1);
+    }
+  }
+  /**
+   * Register an error handler.
+   *
+   * This is used locally within this dispatcher
+   * (does not affect children/parent) whenever
+   * an error is thrown inside an update handler.
+   * Not used for raw update handlers
+   *
+   * When an error is thrown, but there is no error
+   * handler, it is propagated to `TelegramClient`.
+   *
+   * There can be at most one error handler.
+   * Pass `null` to remove it.
+   *
+   * @param handler  Error handler
+   */
+  onError(handler) {
+    if (handler) this._errorHandler = handler;
+    else this._errorHandler = void 0;
+  }
+  /**
+   * Register pre-update middleware.
+   *
+   * This is used locally within this dispatcher
+   * (does not affect children/parent) before processing
+   * an update, and can be used to skip this update.
+   *
+   * There can be at most one pre-update middleware.
+   * Pass `null` to remove it.
+   *
+   * @param handler  Pre-update middleware
+   */
+  onPreUpdate(handler) {
+    if (handler) this._preUpdateHandler = handler;
+    else this._preUpdateHandler = void 0;
+  }
+  /**
+   * Register post-update middleware.
+   *
+   * This is used locally within this dispatcher
+   * (does not affect children/parent) after successfully
+   * processing an update, and can be used for stats.
+   *
+   * There can be at most one post-update middleware.
+   * Pass `null` to remove it.
+   *
+   * @param handler  Pre-update middleware
+   */
+  onPostUpdate(handler) {
+    if (handler) this._postUpdateHandler = handler;
+    else this._postUpdateHandler = void 0;
+  }
+  /**
+   * Set error handler that will propagate
+   * the error to the parent dispatcher
+   */
+  propagateErrorToParent(err, update, state) {
+    if (!this.parent) {
+      throw new core.MtArgumentError("This dispatcher is not a child");
+    }
+    if (this.parent._errorHandler) {
+      return this.parent._errorHandler(err, update, state);
+    }
+    throw err;
+  }
+  // children //
+  /**
+   * Get parent dispatcher if current dispatcher is a child.
+   * Otherwise, return `null`
+   */
+  get parent() {
+    return this._parent ?? null;
+  }
+  _prepareChild(child) {
+    if (child._client) {
+      throw new core.MtArgumentError(
+        `Provided dispatcher is ${child._parent ? "already a child. Use parent.removeChild() before calling addChild()" : "already bound to a client. Use unbind() before calling addChild()"}`
+      );
+    }
+    child._parent = this;
+    child._client = this._client;
+    child._storage = this._storage;
+    child._deps = this._deps;
+    child._scenes = this._scenes;
+    child._stateKeyDelegate = this._stateKeyDelegate;
+    child._customStorage ??= this._customStorage;
+    child._customStateKeyDelegate ??= this._customStateKeyDelegate;
+  }
+  /**
+   * Add a child dispatcher.
+   *
+   * Child dispatchers are called when dispatching updates
+   * just like normal, except they can be controlled
+   * externally. Additionally, child dispatcher have their own
+   * independent handler grouping that does not interfere with parent's,
+   * including `StopPropagation` (i.e. returning `StopPropagation` will
+   * still call children. To entirely stop, use `StopChildrenPropagation`)
+   *
+   * Note that child dispatchers share the same TelegramClient and
+   * storage binding as the parent, don't bind them manually.
+   *
+   * @param child  Other dispatcher
+   */
+  addChild(child) {
+    if (this._children.includes(child)) return;
+    this._prepareChild(child);
+    this._children.push(child);
+  }
+  addScene(scene, scoped = true) {
+    if (!this._scenes) this._scenes = /* @__PURE__ */ new Map();
+    if (!scene._scene) {
+      throw new core.MtArgumentError(
+        "Non-scene dispatcher passed to addScene. Use `Dispatcher.scene()` to create one."
+      );
+    }
+    if (this._scenes.has(scene._scene)) {
+      throw new core.MtArgumentError(`Scene with name ${scene._scene} is already registered!`);
+    }
+    this._prepareChild(scene);
+    scene._sceneScoped = scoped;
+    this._scenes.set(scene._scene, scene);
+  }
+  /**
+   * Remove a child dispatcher.
+   *
+   * Removing child dispatcher will also remove
+   * child dispatcher's client binding.
+   *
+   * If the provided dispatcher is not a child of current,
+   * this function will silently fail.
+   *
+   * @param child  Other dispatcher
+   */
+  removeChild(child) {
+    const idx = this._children.indexOf(child);
+    if (idx > -1) {
+      child._unparent();
+      this._children.splice(idx, 1);
+    }
+  }
+  _unparent() {
+    this._parent = this._client = void 0;
+    this._deps = {};
+    this._stateKeyDelegate = void 0;
+    this._storage = void 0;
+  }
+  /**
+   * Extend current dispatcher by copying other dispatcher's
+   * handlers and children to the current.
+   *
+   * This might be more efficient for simple cases, but do note that the handler
+   * groups, children and scenes will get merged (unlike {@link addChild},
+   * where they are independent). Also note that unlike with children,
+   * when adding handlers to `other` *after* you extended
+   * the current dispatcher, changes will not be applied.
+   *
+   * @param other  Other dispatcher
+   */
+  extend(other) {
+    if (other._customStorage || other._customStateKeyDelegate) {
+      throw new core.MtArgumentError("Provided dispatcher has custom storage and cannot be extended from.");
+    }
+    other._groupsOrder.forEach((group) => {
+      if (!this._groups.has(group)) {
+        this._groups.set(group, other._groups.get(group));
+        this._groupsOrder.push(group);
+      } else {
+        const otherGrp = other._groups.get(group);
+        const selfGrp = this._groups.get(group);
+        for (const typ of otherGrp.keys()) {
+          if (!selfGrp.has(typ)) {
+            selfGrp.set(typ, otherGrp.get(typ));
+          } else {
+            selfGrp.get(typ).push(...otherGrp.get(typ));
+          }
+        }
+      }
+    });
+    other._children.forEach((it) => {
+      it._unparent();
+      this.addChild(it);
+    });
+    if (other._scenes) {
+      const otherScenes = other._scenes;
+      if (!this._scenes) this._scenes = /* @__PURE__ */ new Map();
+      const myScenes = this._scenes;
+      for (const key2 of otherScenes.keys()) {
+        otherScenes.get(key2)._unparent();
+        if (myScenes.has(key2)) {
+          myScenes.delete(key2);
+        }
+        this.addScene(otherScenes.get(key2), otherScenes.get(key2)._sceneScoped);
+      }
+    }
+    this._groupsOrder.sort((a, b) => a - b);
+  }
+  /**
+   * Create a clone of this dispatcher, that has the same handlers,
+   * but is not bound to a client or to a parent dispatcher.
+   *
+   * Custom Storage and key delegate are copied too.
+   *
+   * By default, child dispatchers (and scenes) are ignored, since
+   * that requires cloning every single one of them recursively
+   * and then binding them back.
+   *
+   * @param children  Whether to also clone children and scenes
+   */
+  clone(children = false) {
+    const dp = new Dispatcher();
+    for (const key2 of this._groups.keys()) {
+      const idx = key2;
+      dp._groups.set(idx, /* @__PURE__ */ new Map());
+      for (const type of this._groups.get(idx).keys()) {
+        dp._groups.get(idx).set(type, [...this._groups.get(idx).get(type)]);
+      }
+    }
+    dp._groupsOrder = [...this._groupsOrder];
+    dp._errorHandler = this._errorHandler;
+    dp._customStateKeyDelegate = this._customStateKeyDelegate;
+    dp._customStorage = this._customStorage;
+    if (children) {
+      this._children.forEach((it) => {
+        const child = it.clone(true);
+        dp.addChild(child);
+      });
+      if (this._scenes) {
+        for (const key2 of this._scenes.keys()) {
+          const scene = this._scenes.get(key2).clone(true);
+          dp.addScene(scene, this._scenes.get(key2)._sceneScoped);
+        }
+      }
+    }
+    return dp;
+  }
+  getState(object) {
+    if (!this._storage) {
+      throw new core.MtArgumentError("Cannot use getUpdateState() filter without state storage");
+    }
+    if (typeof object === "string") {
+      return new updateState.UpdateState(this._storage, object, this._scene ?? null, this._sceneScoped, this._customStorage);
+    }
+    return Promise.resolve(this._stateKeyDelegate(object)).then((key2) => {
+      if (!key2) {
+        throw new core.MtArgumentError("Cannot derive key from given object");
+      }
+      if (!this._customStateKeyDelegate) {
+        return new updateState.UpdateState(this._storage, key2, this._scene ?? null, this._sceneScoped, this._customStorage);
+      }
+      return Promise.resolve(this._customStateKeyDelegate(object)).then((customKey) => {
+        if (!customKey) {
+          throw new core.MtArgumentError("Cannot derive custom key from given object");
+        }
+        return new updateState.UpdateState(
+          this._storage,
+          key2,
+          this._scene ?? null,
+          this._sceneScoped,
+          this._customStorage,
+          customKey
+        );
+      });
+    });
+  }
+  /**
+   * Get global state.
+   *
+   * This will load the state for the given object
+   * ignoring local custom storage, key delegate and scene scope.
+   */
+  getGlobalState(object) {
+    if (!this._parent) {
+      throw new core.MtArgumentError("This dispatcher does not have a parent");
+    }
+    return Promise.resolve(this._stateKeyDelegate(object)).then((key2) => {
+      if (!key2) {
+        throw new core.MtArgumentError("Cannot derive key from given object");
+      }
+      return new updateState.UpdateState(this._storage, key2, this._scene ?? null, false);
+    });
+  }
+  // addUpdateHandler convenience wrappers //
+  _addKnownHandler(name, filter, handler, group) {
+    if (typeof handler === "number" || typeof handler === "undefined") {
+      this.addUpdateHandler(
+        {
+          name,
+          callback: filter
+        },
+        handler
+      );
+    } else {
+      this.addUpdateHandler(
+        {
+          name,
+          callback: handler,
+          check: filter
+        },
+        group
+      );
+    }
+  }
+  /** @internal */
+  onRawUpdate(filter, handler, group) {
+    this._addKnownHandler("raw", filter, handler, group);
+  }
+  /**
+   * Register a scene transition handler
+   *
+   * This handler is called whenever a scene transition occurs
+   * in the context of the scene that is being entered,
+   * and before any of the its own handlers are called,
+   * and can be used to customize the transition behavior:
+   *   - `Stop` to prevent dispatching the update any further **even if ToScene/ToRoot was used**
+   *   - `Continue` same as Stop, but still dispatch the update to children
+   *   - `ToScene` to prevent the transition and dispatch the update to the scene entered in the transition handler
+   *
+   * > **Note**: if multiple `state.enter()` calls were made within the same update,
+   * > this handler will only be called for the last one.
+   *
+   * @param handler  Raw update handler
+   * @param group  Handler group index
+   */
+  onSceneTransition(handler) {
+    if (handler) this._sceneTransitionHandler = handler;
+    else this._sceneTransitionHandler = void 0;
+  }
+  /** @internal */
+  onAnyCallbackQuery(filter, handler, group) {
+    this._addKnownHandler("callback_query", filter, handler, group);
+    this._addKnownHandler("inline_callback_query", filter, handler, group);
+    this._addKnownHandler("business_callback_query", filter, handler, group);
+  }
+  /** @internal */
+  onNewMessage(filter, handler, group) {
+    this._addKnownHandler("new_message", filter, handler, group);
+  }
+  /** @internal */
+  onEditMessage(filter, handler, group) {
+    this._addKnownHandler("edit_message", filter, handler, group);
+  }
+  /** @internal */
+  onMessageGroup(filter, handler, group) {
+    this._addKnownHandler("message_group", filter, handler, group);
+  }
+  /** @internal */
+  onDeleteMessage(filter, handler, group) {
+    this._addKnownHandler("delete_message", filter, handler, group);
+  }
+  /** @internal */
+  onChatMemberUpdate(filter, handler, group) {
+    this._addKnownHandler("chat_member", filter, handler, group);
+  }
+  /** @internal */
+  onInlineQuery(filter, handler, group) {
+    this._addKnownHandler("inline_query", filter, handler, group);
+  }
+  /** @internal */
+  onChosenInlineResult(filter, handler, group) {
+    this._addKnownHandler("chosen_inline_result", filter, handler, group);
+  }
+  /** @internal */
+  onCallbackQuery(filter, handler, group) {
+    this._addKnownHandler("callback_query", filter, handler, group);
+  }
+  /** @internal */
+  onInlineCallbackQuery(filter, handler, group) {
+    this._addKnownHandler("inline_callback_query", filter, handler, group);
+  }
+  /** @internal */
+  onBusinessCallbackQuery(filter, handler, group) {
+    this._addKnownHandler("business_callback_query", filter, handler, group);
+  }
+  /** @internal */
+  onPollUpdate(filter, handler, group) {
+    this._addKnownHandler("poll", filter, handler, group);
+  }
+  /** @internal */
+  onPollVote(filter, handler, group) {
+    this._addKnownHandler("poll_vote", filter, handler, group);
+  }
+  /** @internal */
+  onUserStatusUpdate(filter, handler, group) {
+    this._addKnownHandler("user_status", filter, handler, group);
+  }
+  /** @internal */
+  onUserTyping(filter, handler, group) {
+    this._addKnownHandler("user_typing", filter, handler, group);
+  }
+  /** @internal */
+  onHistoryRead(filter, handler, group) {
+    this._addKnownHandler("history_read", filter, handler, group);
+  }
+  /** @internal */
+  onBotStopped(filter, handler, group) {
+    this._addKnownHandler("bot_stopped", filter, handler, group);
+  }
+  /** @internal */
+  onBotChatJoinRequest(filter, handler, group) {
+    this._addKnownHandler("bot_chat_join_request", filter, handler, group);
+  }
+  /** @internal */
+  onChatJoinRequest(filter, handler, group) {
+    this._addKnownHandler("chat_join_request", filter, handler, group);
+  }
+  /** @internal */
+  onPreCheckoutQuery(filter, handler, group) {
+    this._addKnownHandler("pre_checkout_query", filter, handler, group);
+  }
+  /** @internal */
+  onStoryUpdate(filter, handler, group) {
+    this._addKnownHandler("story", filter, handler, group);
+  }
+  /** @internal */
+  onDeleteStory(filter, handler, group) {
+    this._addKnownHandler("delete_story", filter, handler, group);
+  }
+  /** @internal */
+  onBotReactionUpdate(filter, handler, group) {
+    this._addKnownHandler("bot_reaction", filter, handler, group);
+  }
+  /** @internal */
+  onBotReactionCountUpdate(filter, handler, group) {
+    this._addKnownHandler("bot_reaction_count", filter, handler, group);
+  }
+  /** @internal */
+  onBusinessConnectionUpdate(filter, handler, group) {
+    this._addKnownHandler("business_connection", filter, handler, group);
+  }
+  /** @internal */
+  onNewBusinessMessage(filter, handler, group) {
+    this._addKnownHandler("new_business_message", filter, handler, group);
+  }
+  /** @internal */
+  onEditBusinessMessage(filter, handler, group) {
+    this._addKnownHandler("edit_business_message", filter, handler, group);
+  }
+  /** @internal */
+  onBusinessMessageGroup(filter, handler, group) {
+    this._addKnownHandler("business_message_group", filter, handler, group);
+  }
+  /** @internal */
+  onDeleteBusinessMessage(filter, handler, group) {
+    this._addKnownHandler("delete_business_message", filter, handler, group);
+  }
+  // end-codegen
+}
+exports.Dispatcher = Dispatcher;