@mtcute/dispatcher 0.1.0

package/cjs/dispatcher.d.ts

@@ -0,0 +1,641 @@
+import { BotStoppedUpdate, ChatJoinRequestUpdate, ChatMemberUpdate, DeleteMessageUpdate, DeleteStoryUpdate, HistoryReadUpdate, MaybeAsync, ParsedUpdate, PeersIndex, PollUpdate, PollVoteUpdate, StoryUpdate, TelegramClient, tl, UserStatusUpdate, UserTypingUpdate } from '@mtcute/client';
+import { UpdateContext } from './context/base.js';
+import { CallbackQueryContext, ChatJoinRequestUpdateContext, ChosenInlineResultContext, InlineQueryContext, MessageContext, PreCheckoutQueryContext } from './context/index.js';
+import { filters, UpdateFilter } from './filters/index.js';
+import { BotChatJoinRequestHandler, BotStoppedHandler, CallbackQueryHandler, ChatJoinRequestHandler, ChatMemberUpdateHandler, ChosenInlineResultHandler, DeleteMessageHandler, DeleteStoryHandler, EditMessageHandler, HistoryReadHandler, InlineQueryHandler, MessageGroupHandler, NewMessageHandler, PollUpdateHandler, PollVoteHandler, PreCheckoutQueryHandler, RawUpdateHandler, StoryUpdateHandler, UpdateHandler, UserStatusUpdateHandler, UserTypingHandler } from './handler.js';
+import { PropagationAction } from './propagation.js';
+import { IStateStorage, StateKeyDelegate, UpdateState } from './state/index.js';
+export interface DispatcherParams {
+    /**
+     * If this dispatcher can be used as a scene, its unique name.
+     *
+     * Should not be set manually, use {@link Dispatcher.scene} instead
+     */
+    sceneName?: string;
+    /**
+     * Custom storage for the dispatcher.
+     *
+     * @default  Client's storage
+     */
+    storage?: IStateStorage;
+    /**
+     * Custom key delegate for the dispatcher.
+     */
+    key?: StateKeyDelegate;
+}
+/**
+ * Updates dispatcher
+ */
+export declare class Dispatcher<State extends object = never> {
+    private _groups;
+    private _groupsOrder;
+    private _client?;
+    private _parent?;
+    private _children;
+    private _scenes?;
+    private _scene?;
+    private _sceneScoped?;
+    private _storage?;
+    private _stateKeyDelegate?;
+    private _customStateKeyDelegate?;
+    private _customStorage?;
+    private _errorHandler?;
+    private _preUpdateHandler?;
+    private _postUpdateHandler?;
+    protected constructor(client?: TelegramClient, params?: DispatcherParams);
+    /**
+     * Create a new dispatcher and bind it to the client.
+     */
+    static for<State extends object = never>(client: TelegramClient, params?: DispatcherParams): Dispatcher<State>;
+    /**
+     * Create a new child dispatcher.
+     */
+    static child<State extends object = never>(params?: DispatcherParams): Dispatcher<State>;
+    /**
+     * Create a new scene dispatcher
+     */
+    static scene<State extends object = Record<never, never>>(name: string, params?: Omit<DispatcherParams, 'sceneName'>): Dispatcher<State>;
+    /** For scene dispatchers, name of the scene */
+    get sceneName(): string | undefined;
+    /**
+     * Bind the dispatcher to the client.
+     * Called by the constructor automatically if
+     * `client` was passed.
+     *
+     * Under the hood, this replaces client's `dispatchUpdate`
+     * function, meaning you can't bind two different
+     * dispatchers to the same client at the same time.
+     * Instead, use {@link extend}, {@link addChild}
+     * or {@link addScene} on the existing, already bound dispatcher.
+     *
+     * Dispatcher also uses bound client to throw errors
+     */
+    bindToClient(client: TelegramClient): void;
+    /**
+     * Unbind a dispatcher from the client.
+     *
+     * This will replace client's dispatchUpdate with a no-op.
+     * If this dispatcher is not bound, nothing will happen.
+     */
+    unbind(): void;
+    /**
+     * 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: tl.TypeUpdate | tl.TypeMessage, peers: PeersIndex): void;
+    /**
+     * 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
+     */
+    dispatchRawUpdateNow(update: tl.TypeUpdate | tl.TypeMessage, peers: PeersIndex): Promise<boolean>;
+    /**
+     * 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: ParsedUpdate): void;
+    /**
+     * 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
+     */
+    dispatchUpdateNow(update: ParsedUpdate): Promise<boolean>;
+    private _dispatchUpdateNowImpl;
+    /**
+     * Add an update handler to a given handlers group
+     *
+     * @param handler  Update handler
+     * @param group  Handler group index
+     */
+    addUpdateHandler(handler: UpdateHandler, group?: number): void;
+    /**
+     * 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 (-1 to affect all groups)
+     */
+    removeUpdateHandler(handler: UpdateHandler | UpdateHandler['name'] | 'all', group?: number): void;
+    /**
+     * 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<T = {}>(handler: ((err: Error, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybeAsync<boolean>) | null): void;
+    /**
+     * 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<T = {}>(handler: ((update: ParsedUpdate & T, state?: UpdateState<State>) => MaybeAsync<PropagationAction | void>) | null): void;
+    /**
+     * 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<T = {}>(handler: ((handled: boolean, update: ParsedUpdate & T, state?: UpdateState<State>) => MaybeAsync<void>) | null): void;
+    /**
+     * Set error handler that will propagate
+     * the error to the parent dispatcher
+     */
+    propagateErrorToParent(err: Error, update: ParsedUpdate, state?: UpdateState<State>): MaybeAsync<boolean>;
+    /**
+     * Get parent dispatcher if current dispatcher is a child.
+     * Otherwise, return `null`
+     */
+    get parent(): Dispatcher<any> | null;
+    private _prepareChild;
+    /**
+     * 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: Dispatcher<State>): void;
+    /**
+     * Add a dispatcher as a scene with a non-scoped state.
+     *
+     * Scoped storage for a scene means that the scene will
+     * have its own storage, that is only available within
+     * the scene and does not interfere with global state.
+     * Non-scoped, on the other hand, is the same state as
+     * the one used for the root dispatcher
+     *
+     * @param uid  UID of the scene
+     * @param scene  Dispatcher representing the scene
+     * @param scoped  Whether to use scoped FSM storage for the scene
+     */
+    addScene(scene: Dispatcher<State>, scoped: false): void;
+    /**
+     * Add a dispatcher as a scene with a scoped state
+     *
+     * Scoped storage for a scene means that the scene will
+     * have its own storage, that is only available within
+     * the scene and does not interfere with global state.
+     * Non-scoped, on the other hand, is the same state as
+     * the one used for the root dispatcher
+     *
+     * @param uid  UID of the scene
+     * @param scene  Dispatcher representing the scene
+     * @param scoped  Whether to use scoped FSM storage for the scene (defaults to `true`)
+     */
+    addScene(scene: Dispatcher<any>, scoped?: true): void;
+    /**
+     * 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: Dispatcher<any>): void;
+    private _unparent;
+    /**
+     * 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: Dispatcher<State>): void;
+    /**
+     * 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?: boolean): Dispatcher<State>;
+    /**
+     * Get update state object for the given key.
+     *
+     * For custom keys, use prefix starting with `$` to avoid
+     * clashing with other keys (scene name can't start with `$`)
+     *
+     * @param key  State storage key
+     * @template S  State type, defaults to dispatcher's state type. Only checked at compile-time
+     */
+    getState<S extends object = State>(key: string): UpdateState<S>;
+    /**
+     * Get update state object for the given object.
+     *
+     * Equivalent to `getState(string)`, but derives
+     * the key with the registered {@link StateKeyDelegate},
+     * and since it could be async, this method is async too.
+     *
+     * @param object  Object for which the state should be fetched
+     * @template S  State type, defaults to dispatcher's state type. Only checked at compile-time
+     */
+    getState<S extends object = State>(object: Parameters<StateKeyDelegate>[0]): Promise<UpdateState<S>>;
+    /**
+     * Get global state.
+     *
+     * This will load the state for the given object
+     * ignoring local custom storage, key delegate and scene scope.
+     */
+    getGlobalState<T extends object>(object: Parameters<StateKeyDelegate>[0]): Promise<UpdateState<T>>;
+    private _addKnownHandler;
+    /**
+     * Register a raw update handler without any filters
+     *
+     * @param handler  Raw update handler
+     * @param group  Handler group index
+     */
+    onRawUpdate(handler: RawUpdateHandler['callback'], group?: number): void;
+    /**
+     * Register a raw update handler without any filters
+     *
+     * @param filter  Update filter
+     * @param handler  Raw update handler
+     * @param group  Handler group index
+     */
+    onRawUpdate(filter: RawUpdateHandler['check'], handler: RawUpdateHandler['callback'], group?: number): void;
+    /**
+     * Register a new message handler without any filters
+     *
+     * @param handler  New message handler
+     * @param group  Handler group index
+     */
+    onNewMessage(handler: NewMessageHandler<MessageContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register a new message handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  New message handler
+     * @param group  Handler group index
+     */
+    onNewMessage<Mod>(filter: UpdateFilter<MessageContext, Mod, State>, handler: NewMessageHandler<filters.Modify<MessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register a new message handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  New message handler
+     * @param group  Handler group index
+     */
+    onNewMessage<Mod>(filter: UpdateFilter<MessageContext, Mod>, handler: NewMessageHandler<filters.Modify<MessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register an edit message handler without any filters
+     *
+     * @param handler  Edit message handler
+     * @param group  Handler group index
+     */
+    onEditMessage(handler: EditMessageHandler<MessageContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register an edit message handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Edit message handler
+     * @param group  Handler group index
+     */
+    onEditMessage<Mod>(filter: UpdateFilter<MessageContext, Mod, State>, handler: EditMessageHandler<filters.Modify<MessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register an edit message handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Edit message handler
+     * @param group  Handler group index
+     */
+    onEditMessage<Mod>(filter: UpdateFilter<MessageContext, Mod>, handler: EditMessageHandler<filters.Modify<MessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register a message group handler without any filters
+     *
+     * @param handler  Message group handler
+     * @param group  Handler group index
+     */
+    onMessageGroup(handler: MessageGroupHandler<MessageContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register a message group handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Message group handler
+     * @param group  Handler group index
+     */
+    onMessageGroup<Mod>(filter: UpdateFilter<MessageContext, Mod, State>, handler: MessageGroupHandler<filters.Modify<MessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register a message group handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Message group handler
+     * @param group  Handler group index
+     */
+    onMessageGroup<Mod>(filter: UpdateFilter<MessageContext, Mod>, handler: MessageGroupHandler<filters.Modify<MessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register a delete message handler without any filters
+     *
+     * @param handler  Delete message handler
+     * @param group  Handler group index
+     */
+    onDeleteMessage(handler: DeleteMessageHandler['callback'], group?: number): void;
+    /**
+     * Register a delete message handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Delete message handler
+     * @param group  Handler group index
+     */
+    onDeleteMessage<Mod>(filter: UpdateFilter<UpdateContext<DeleteMessageUpdate>, Mod>, handler: DeleteMessageHandler<filters.Modify<UpdateContext<DeleteMessageUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a chat member update handler without any filters
+     *
+     * @param handler  Chat member update handler
+     * @param group  Handler group index
+     */
+    onChatMemberUpdate(handler: ChatMemberUpdateHandler['callback'], group?: number): void;
+    /**
+     * Register a chat member update handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Chat member update handler
+     * @param group  Handler group index
+     */
+    onChatMemberUpdate<Mod>(filter: UpdateFilter<UpdateContext<ChatMemberUpdate>, Mod>, handler: ChatMemberUpdateHandler<filters.Modify<UpdateContext<ChatMemberUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register an inline query handler without any filters
+     *
+     * @param handler  Inline query handler
+     * @param group  Handler group index
+     */
+    onInlineQuery(handler: InlineQueryHandler['callback'], group?: number): void;
+    /**
+     * Register an inline query handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Inline query handler
+     * @param group  Handler group index
+     */
+    onInlineQuery<Mod>(filter: UpdateFilter<InlineQueryContext, Mod>, handler: InlineQueryHandler<filters.Modify<InlineQueryContext, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a chosen inline result handler without any filters
+     *
+     * @param handler  Chosen inline result handler
+     * @param group  Handler group index
+     */
+    onChosenInlineResult(handler: ChosenInlineResultHandler['callback'], group?: number): void;
+    /**
+     * Register a chosen inline result handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Chosen inline result handler
+     * @param group  Handler group index
+     */
+    onChosenInlineResult<Mod>(filter: UpdateFilter<ChosenInlineResultContext, Mod>, handler: ChosenInlineResultHandler<filters.Modify<ChosenInlineResultContext, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a callback query handler without any filters
+     *
+     * @param handler  Callback query handler
+     * @param group  Handler group index
+     */
+    onCallbackQuery(handler: CallbackQueryHandler<CallbackQueryContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register a callback query handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Callback query handler
+     * @param group  Handler group index
+     */
+    onCallbackQuery<Mod>(filter: UpdateFilter<CallbackQueryContext, Mod, State>, handler: CallbackQueryHandler<filters.Modify<CallbackQueryContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register a callback query handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Callback query handler
+     * @param group  Handler group index
+     */
+    onCallbackQuery<Mod>(filter: UpdateFilter<CallbackQueryContext, Mod>, handler: CallbackQueryHandler<filters.Modify<CallbackQueryContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
+    /**
+     * Register a poll update handler without any filters
+     *
+     * @param handler  Poll update handler
+     * @param group  Handler group index
+     */
+    onPollUpdate(handler: PollUpdateHandler['callback'], group?: number): void;
+    /**
+     * Register a poll update handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Poll update handler
+     * @param group  Handler group index
+     */
+    onPollUpdate<Mod>(filter: UpdateFilter<UpdateContext<PollUpdate>, Mod>, handler: PollUpdateHandler<filters.Modify<UpdateContext<PollUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a poll vote handler without any filters
+     *
+     * @param handler  Poll vote handler
+     * @param group  Handler group index
+     */
+    onPollVote(handler: PollVoteHandler['callback'], group?: number): void;
+    /**
+     * Register a poll vote handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Poll vote handler
+     * @param group  Handler group index
+     */
+    onPollVote<Mod>(filter: UpdateFilter<UpdateContext<PollVoteUpdate>, Mod>, handler: PollVoteHandler<filters.Modify<UpdateContext<PollVoteUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register an user status update handler without any filters
+     *
+     * @param handler  User status update handler
+     * @param group  Handler group index
+     */
+    onUserStatusUpdate(handler: UserStatusUpdateHandler['callback'], group?: number): void;
+    /**
+     * Register an user status update handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  User status update handler
+     * @param group  Handler group index
+     */
+    onUserStatusUpdate<Mod>(filter: UpdateFilter<UpdateContext<UserStatusUpdate>, Mod>, handler: UserStatusUpdateHandler<filters.Modify<UpdateContext<UserStatusUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register an user typing handler without any filters
+     *
+     * @param handler  User typing handler
+     * @param group  Handler group index
+     */
+    onUserTyping(handler: UserTypingHandler['callback'], group?: number): void;
+    /**
+     * Register an user typing handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  User typing handler
+     * @param group  Handler group index
+     */
+    onUserTyping<Mod>(filter: UpdateFilter<UpdateContext<UserTypingUpdate>, Mod>, handler: UserTypingHandler<filters.Modify<UpdateContext<UserTypingUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a history read handler without any filters
+     *
+     * @param handler  History read handler
+     * @param group  Handler group index
+     */
+    onHistoryRead(handler: HistoryReadHandler['callback'], group?: number): void;
+    /**
+     * Register a history read handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  History read handler
+     * @param group  Handler group index
+     */
+    onHistoryRead<Mod>(filter: UpdateFilter<UpdateContext<HistoryReadUpdate>, Mod>, handler: HistoryReadHandler<filters.Modify<UpdateContext<HistoryReadUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a bot stopped handler without any filters
+     *
+     * @param handler  Bot stopped handler
+     * @param group  Handler group index
+     */
+    onBotStopped(handler: BotStoppedHandler['callback'], group?: number): void;
+    /**
+     * Register a bot stopped handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Bot stopped handler
+     * @param group  Handler group index
+     */
+    onBotStopped<Mod>(filter: UpdateFilter<UpdateContext<BotStoppedUpdate>, Mod>, handler: BotStoppedHandler<filters.Modify<UpdateContext<BotStoppedUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a bot chat join request handler without any filters
+     *
+     * @param handler  Bot chat join request handler
+     * @param group  Handler group index
+     */
+    onBotChatJoinRequest(handler: BotChatJoinRequestHandler['callback'], group?: number): void;
+    /**
+     * Register a bot chat join request handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Bot chat join request handler
+     * @param group  Handler group index
+     */
+    onBotChatJoinRequest<Mod>(filter: UpdateFilter<ChatJoinRequestUpdateContext, Mod>, handler: BotChatJoinRequestHandler<filters.Modify<ChatJoinRequestUpdateContext, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a chat join request handler without any filters
+     *
+     * @param handler  Chat join request handler
+     * @param group  Handler group index
+     */
+    onChatJoinRequest(handler: ChatJoinRequestHandler['callback'], group?: number): void;
+    /**
+     * Register a chat join request handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Chat join request handler
+     * @param group  Handler group index
+     */
+    onChatJoinRequest<Mod>(filter: UpdateFilter<UpdateContext<ChatJoinRequestUpdate>, Mod>, handler: ChatJoinRequestHandler<filters.Modify<UpdateContext<ChatJoinRequestUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a pre checkout query handler without any filters
+     *
+     * @param handler  Pre checkout query handler
+     * @param group  Handler group index
+     */
+    onPreCheckoutQuery(handler: PreCheckoutQueryHandler['callback'], group?: number): void;
+    /**
+     * Register a pre checkout query handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Pre checkout query handler
+     * @param group  Handler group index
+     */
+    onPreCheckoutQuery<Mod>(filter: UpdateFilter<PreCheckoutQueryContext, Mod>, handler: PreCheckoutQueryHandler<filters.Modify<PreCheckoutQueryContext, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a story update handler without any filters
+     *
+     * @param handler  Story update handler
+     * @param group  Handler group index
+     */
+    onStoryUpdate(handler: StoryUpdateHandler['callback'], group?: number): void;
+    /**
+     * Register a story update handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Story update handler
+     * @param group  Handler group index
+     */
+    onStoryUpdate<Mod>(filter: UpdateFilter<UpdateContext<StoryUpdate>, Mod>, handler: StoryUpdateHandler<filters.Modify<UpdateContext<StoryUpdate>, Mod>>['callback'], group?: number): void;
+    /**
+     * Register a delete story handler without any filters
+     *
+     * @param handler  Delete story handler
+     * @param group  Handler group index
+     */
+    onDeleteStory(handler: DeleteStoryHandler['callback'], group?: number): void;
+    /**
+     * Register a delete story handler with a filter
+     *
+     * @param filter  Update filter
+     * @param handler  Delete story handler
+     * @param group  Handler group index
+     */
+    onDeleteStory<Mod>(filter: UpdateFilter<UpdateContext<DeleteStoryUpdate>, Mod>, handler: DeleteStoryHandler<filters.Modify<UpdateContext<DeleteStoryUpdate>, Mod>>['callback'], group?: number): void;
+}