import { BotReactionCountUpdate, BotReactionUpdate, BotStoppedUpdate, BusinessConnection, ChatJoinRequestUpdate, ChatMemberUpdate, DeleteBusinessMessageUpdate, DeleteMessageUpdate, DeleteStoryUpdate, HistoryReadUpdate, MaybePromise, ParsedUpdate, PeersIndex, PollUpdate, PollVoteUpdate, RawUpdateInfo, StoryUpdate, tl, UserStatusUpdate, UserTypingUpdate } from '@mtcute/core';
import { TelegramClient } from '@mtcute/core/client.js';
import { UpdateContext } from './context/base.js';
import { BusinessMessageContext } from './context/business-message.js';
import { BusinessCallbackQueryContext, CallbackQueryContext, ChatJoinRequestUpdateContext, ChosenInlineResultContext, InlineCallbackQueryContext, InlineQueryContext, MessageContext, PreCheckoutQueryContext } from './context/index.js';
import { filters, UpdateFilter } from './filters/index.js';
import { BotChatJoinRequestHandler, BotReactionCountUpdateHandler, BotReactionUpdateHandler, BotStoppedHandler, BusinessCallbackQueryHandler, BusinessConnectionUpdateHandler, BusinessMessageGroupHandler, CallbackQueryHandler, ChatJoinRequestHandler, ChatMemberUpdateHandler, ChosenInlineResultHandler, DeleteBusinessMessageHandler, DeleteMessageHandler, DeleteStoryHandler, EditBusinessMessageHandler, EditMessageHandler, HistoryReadHandler, InlineCallbackQueryHandler, InlineQueryHandler, MessageGroupHandler, NewBusinessMessageHandler, NewMessageHandler, PollUpdateHandler, PollVoteHandler, PreCheckoutQueryHandler, RawUpdateHandler, StoryUpdateHandler, UpdateHandler, UserStatusUpdateHandler, UserTypingHandler } from './handler.js';
import { PropagationAction } from './propagation.js';
import { IStateStorageProvider, StateKeyDelegate, UpdateState } from './state/index.js';
import { SceneTransitionContext } from './context/scene-transition.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 this dispatcher and its children.
     *
     * @default  Client's storage
     */
    storage?: IStateStorageProvider;
    /**
     * Custom key delegate for the dispatcher.
     */
    key?: StateKeyDelegate;
}
export interface DispatcherDependencies {
}
/**
 * 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 _deps;
    private _errorHandler?;
    private _preUpdateHandler?;
    private _postUpdateHandler?;
    private _sceneTransitionHandler?;
    protected constructor(client?: TelegramClient, params?: DispatcherParams);
    /**
     * Create a new dispatcher and bind it to the client.
     */
    static for<State extends object = never>(client: TelegramClient, ...args: [State] extends [never] ? [params?: DispatcherParams] : [params: DispatcherParams & {
        storage: IStateStorageProvider;
    }]): 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;
    /**
     * Inject a dependency to be available in this dispatcher and all its children.
     *
     * **Note**: This is only available for the root dispatcher.
     */
    inject<Name extends keyof DispatcherDependencies>(name: Name, value: DispatcherDependencies[Name]): void;
    /**
     * Inject dependencies to be available in this dispatcher and all its children.
     *
     * **Note**: This is only available for the root dispatcher.
     */
    inject(deps: Partial<DispatcherDependencies>): void;
    /**
     * Get the dependencies injected into this dispatcher.
     */
    get deps(): DispatcherDependencies;
    /**
     * 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: TelegramClient): void;
    /**
     * Unbind a dispatcher from the client.
     */
    unbind(): void;
    /**
     * Destroy the dispatcher and all its children.
     *
     * When destroying, all the registered handlers are removed,
     * and the underlying storage is freed.
     */
    destroy(): Promise<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, peers }: RawUpdateInfo): 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 (null to affect all groups)
     */
    removeUpdateHandler(handler: UpdateHandler | UpdateHandler['name'] | 'all', group?: number | null): 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>) => MaybePromise<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>) => MaybePromise<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>) => MaybePromise<void>) | null): void;
    /**
     * Set error handler that will propagate
     * the error to the parent dispatcher
     */
    propagateErrorToParent(err: Error, update: ParsedUpdate, state?: UpdateState<State>): MaybePromise<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> | Dispatcher<never>, 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> | Dispatcher<never>): 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 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: ((ctx: SceneTransitionContext, state: UpdateState<State>) => MaybePromise<PropagationAction | void>) | null): void;
    /**
     * Register a callback query (both inline and non-inline) handler without any filters
     *
     * @param handler  Callback query handler
     * @param group  Handler group index
     */
    onAnyCallbackQuery(handler: CallbackQueryHandler<CallbackQueryContext | InlineCallbackQueryContext | BusinessCallbackQueryContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a callback query (both inline and non-inline) handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Callback query handler
     * @param group  Handler group index
     */
    onAnyCallbackQuery<Mod>(filter: UpdateFilter<CallbackQueryContext | InlineCallbackQueryContext | BusinessCallbackQueryContext, Mod, State>, handler: CallbackQueryHandler<filters.Modify<CallbackQueryContext | InlineCallbackQueryContext | BusinessCallbackQueryContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a callback query (both inline and non-inline) handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Callback query handler
     * @param group  Handler group index
     */
    onAnyCallbackQuery<Mod>(filter: UpdateFilter<CallbackQueryContext | InlineCallbackQueryContext | BusinessCallbackQueryContext, Mod>, handler: CallbackQueryHandler<filters.Modify<CallbackQueryContext | InlineCallbackQueryContext | BusinessCallbackQueryContext, Mod>, State extends never ? never : UpdateState<State>>['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 an inline callback query handler without any filters
     *
     * @param handler  Inline callback query handler
     * @param group  Handler group index
     */
    onInlineCallbackQuery(handler: InlineCallbackQueryHandler<InlineCallbackQueryContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register an inline callback query handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Inline callback query handler
     * @param group  Handler group index
     */
    onInlineCallbackQuery<Mod>(filter: UpdateFilter<InlineCallbackQueryContext, Mod, State>, handler: InlineCallbackQueryHandler<filters.Modify<InlineCallbackQueryContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register an inline callback query handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Inline callback query handler
     * @param group  Handler group index
     */
    onInlineCallbackQuery<Mod>(filter: UpdateFilter<InlineCallbackQueryContext, Mod>, handler: InlineCallbackQueryHandler<filters.Modify<InlineCallbackQueryContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a business callback query handler without any filters
     *
     * @param handler  Business callback query handler
     * @param group  Handler group index
     */
    onBusinessCallbackQuery(handler: BusinessCallbackQueryHandler<BusinessCallbackQueryContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a business callback query handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Business callback query handler
     * @param group  Handler group index
     */
    onBusinessCallbackQuery<Mod>(filter: UpdateFilter<BusinessCallbackQueryContext, Mod, State>, handler: BusinessCallbackQueryHandler<filters.Modify<BusinessCallbackQueryContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a business callback query handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Business callback query handler
     * @param group  Handler group index
     */
    onBusinessCallbackQuery<Mod>(filter: UpdateFilter<BusinessCallbackQueryContext, Mod>, handler: BusinessCallbackQueryHandler<filters.Modify<BusinessCallbackQueryContext, 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;
    /**
     * Register a bot reaction update handler without any filters
     *
     * @param handler  Bot reaction update handler
     * @param group  Handler group index
     */
    onBotReactionUpdate(handler: BotReactionUpdateHandler['callback'], group?: number): void;
    /**
     * Register a bot reaction update handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Bot reaction update handler
     * @param group  Handler group index
     */
    onBotReactionUpdate<Mod>(filter: UpdateFilter<UpdateContext<BotReactionUpdate>, Mod>, handler: BotReactionUpdateHandler<filters.Modify<UpdateContext<BotReactionUpdate>, Mod>>['callback'], group?: number): void;
    /**
     * Register a bot reaction count update handler without any filters
     *
     * @param handler  Bot reaction count update handler
     * @param group  Handler group index
     */
    onBotReactionCountUpdate(handler: BotReactionCountUpdateHandler['callback'], group?: number): void;
    /**
     * Register a bot reaction count update handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Bot reaction count update handler
     * @param group  Handler group index
     */
    onBotReactionCountUpdate<Mod>(filter: UpdateFilter<UpdateContext<BotReactionCountUpdate>, Mod>, handler: BotReactionCountUpdateHandler<filters.Modify<UpdateContext<BotReactionCountUpdate>, Mod>>['callback'], group?: number): void;
    /**
     * Register a business connection update handler without any filters
     *
     * @param handler  Business connection update handler
     * @param group  Handler group index
     */
    onBusinessConnectionUpdate(handler: BusinessConnectionUpdateHandler['callback'], group?: number): void;
    /**
     * Register a business connection update handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Business connection update handler
     * @param group  Handler group index
     */
    onBusinessConnectionUpdate<Mod>(filter: UpdateFilter<UpdateContext<BusinessConnection>, Mod>, handler: BusinessConnectionUpdateHandler<filters.Modify<UpdateContext<BusinessConnection>, Mod>>['callback'], group?: number): void;
    /**
     * Register a new business message handler without any filters
     *
     * @param handler  New business message handler
     * @param group  Handler group index
     */
    onNewBusinessMessage(handler: NewBusinessMessageHandler<BusinessMessageContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a new business message handler with a filter
     *
     * @param filter  Update filter
     * @param handler  New business message handler
     * @param group  Handler group index
     */
    onNewBusinessMessage<Mod>(filter: UpdateFilter<BusinessMessageContext, Mod, State>, handler: NewBusinessMessageHandler<filters.Modify<BusinessMessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a new business message handler with a filter
     *
     * @param filter  Update filter
     * @param handler  New business message handler
     * @param group  Handler group index
     */
    onNewBusinessMessage<Mod>(filter: UpdateFilter<BusinessMessageContext, Mod>, handler: NewBusinessMessageHandler<filters.Modify<BusinessMessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register an edit business message handler without any filters
     *
     * @param handler  Edit business message handler
     * @param group  Handler group index
     */
    onEditBusinessMessage(handler: EditBusinessMessageHandler<BusinessMessageContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register an edit business message handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Edit business message handler
     * @param group  Handler group index
     */
    onEditBusinessMessage<Mod>(filter: UpdateFilter<BusinessMessageContext, Mod, State>, handler: EditBusinessMessageHandler<filters.Modify<BusinessMessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register an edit business message handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Edit business message handler
     * @param group  Handler group index
     */
    onEditBusinessMessage<Mod>(filter: UpdateFilter<BusinessMessageContext, Mod>, handler: EditBusinessMessageHandler<filters.Modify<BusinessMessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a business message group handler without any filters
     *
     * @param handler  Business message group handler
     * @param group  Handler group index
     */
    onBusinessMessageGroup(handler: BusinessMessageGroupHandler<BusinessMessageContext, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a business message group handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Business message group handler
     * @param group  Handler group index
     */
    onBusinessMessageGroup<Mod>(filter: UpdateFilter<BusinessMessageContext, Mod, State>, handler: BusinessMessageGroupHandler<filters.Modify<BusinessMessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a business message group handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Business message group handler
     * @param group  Handler group index
     */
    onBusinessMessageGroup<Mod>(filter: UpdateFilter<BusinessMessageContext, Mod>, handler: BusinessMessageGroupHandler<filters.Modify<BusinessMessageContext, Mod>, State extends never ? never : UpdateState<State>>['callback'], group?: number): void;
    /**
     * Register a delete business message handler without any filters
     *
     * @param handler  Delete business message handler
     * @param group  Handler group index
     */
    onDeleteBusinessMessage(handler: DeleteBusinessMessageHandler['callback'], group?: number): void;
    /**
     * Register a delete business message handler with a filter
     *
     * @param filter  Update filter
     * @param handler  Delete business message handler
     * @param group  Handler group index
     */
    onDeleteBusinessMessage<Mod>(filter: UpdateFilter<UpdateContext<DeleteBusinessMessageUpdate>, Mod>, handler: DeleteBusinessMessageHandler<filters.Modify<UpdateContext<DeleteBusinessMessageUpdate>, Mod>>['callback'], group?: number): void;
}