@mtkruto/node 0.1.112 → 0.1.114

package/esm/0_deps.d.ts

@@ -1,8 +1,9 @@
-export * from "./deps/deno.land/std@0.204.0/assert/mod.js";
+export * from "./deps/deno.land/std@0.207.0/assert/mod.js";
+export * as path from "./deps/deno.land/std@0.207.0/path/mod.js";
+export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.207.0/encoding/base64.js";
 export { ctr256, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.3.3/mod.js";
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/main/gzip/gzip.js";
 export { Mutex, type MutexInterface } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/main/mod.js";
 export declare const debug: typeof debug_;
-export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.204.0/encoding/base64.js";

package/esm/0_deps.js

@@ -1,8 +1,9 @@
-export * from "./deps/deno.land/std@0.204.0/assert/mod.js";
+export * from "./deps/deno.land/std@0.207.0/assert/mod.js";
+export * as path from "./deps/deno.land/std@0.207.0/path/mod.js";
+export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.207.0/encoding/base64.js";
 export { ctr256, factorize, ige256Decrypt, ige256Encrypt, init as initTgCrypto } from "./deps/deno.land/x/tgcrypto@0.3.3/mod.js";
 export { gunzip, gzip } from "./deps/raw.githubusercontent.com/MTKruto/compress/main/gzip/gzip.js";
 export { Mutex } from "async-mutex";
 export { Parser } from "./deps/deno.land/x/html_parser@v0.1.3/src/mod.js";
 import { debug as debug_ } from "./deps/raw.githubusercontent.com/MTKruto/debug/main/mod.js";
 export const debug = (v) => debug_(v);
-export { decodeBase64, encodeBase64 } from "./deps/deno.land/std@0.204.0/encoding/base64.js";

package/esm/1_utilities.d.ts

@@ -1,6 +1,7 @@
 export * from "./utilities/0_base64.js";
 export * from "./utilities/0_bigint.js";
 export * from "./utilities/0_buffer.js";
+export * from "./utilities/0_color.js";
 export * from "./utilities/0_control.js";
 export * from "./utilities/0_crypto.js";
 export * from "./utilities/0_hash.js";

package/esm/1_utilities.js

@@ -1,6 +1,7 @@
 export * from "./utilities/0_base64.js";
 export * from "./utilities/0_bigint.js";
 export * from "./utilities/0_buffer.js";
+export * from "./utilities/0_color.js";
 export * from "./utilities/0_control.js";
 export * from "./utilities/0_crypto.js";
 export * from "./utilities/0_hash.js";

package/esm/3_types.d.ts

@@ -4,7 +4,6 @@ export * from "./types/0_chat_action.js";
 export * from "./types/0_chat_administrator_rights.js";
 export * from "./types/0_chat_id.js";
 export * from "./types/0_chat_photo.js";
-export * from "./types/0_color.js";
 export * from "./types/0_contact.js";
 export * from "./types/0_dice.js";
 export * from "./types/0__file_id.js";

package/esm/3_types.js

@@ -4,7 +4,6 @@ export * from "./types/0_chat_action.js";
 export * from "./types/0_chat_administrator_rights.js";
 export * from "./types/0_chat_id.js";
 export * from "./types/0_chat_photo.js";
-export * from "./types/0_color.js";
 export * from "./types/0_contact.js";
 export * from "./types/0_dice.js";
 export * from "./types/0__file_id.js";

package/esm/4_constants.d.ts

@@ -5,7 +5,7 @@ export declare const PUBLIC_KEYS: PublicKeys;
 export declare const VECTOR_CONSTRUCTOR = 481674261;
 export declare const INITIAL_DC: DC;
 export declare const LAYER = 166;
-export declare const APP_VERSION = "MTKruto 0.1.112";
+export declare const APP_VERSION = "MTKruto 0.1.114";
 export declare const DEVICE_MODEL: string;
 export declare const LANG_CODE: string;
 export declare const LANG_PACK = "";

package/esm/4_constants.js

@@ -54,7 +54,7 @@ export const PUBLIC_KEYS = Object.freeze([
 export const VECTOR_CONSTRUCTOR = 0x1CB5C415;
 export const INITIAL_DC = "2";
 export const LAYER = 166;
-export const APP_VERSION = "MTKruto 0.1.112";
+export const APP_VERSION = "MTKruto 0.1.114";
 // @ts-ignore: lib
 export const DEVICE_MODEL = typeof dntShim.Deno === "undefined" ? typeof navigator === "undefined" ? typeof process === "undefined" ? "Unknown" : process.platform + "-" + process.arch : navigator.userAgent.split(" ")[0] : dntShim.Deno.build.os + "-" + dntShim.Deno.build.arch;
 export const LANG_CODE = typeof navigator === "undefined" ? "en" : navigator.language.split("-")[0];

package/esm/5_client.d.ts

@@ -1,3 +1,4 @@
 export * from "./client/2_client_plain.js";
 export * from "./client/3_types.js";
-export * from "./client/4_client.js";
+export * from "./client/5_client.js";
+export * from "./client/6_composer.js";

package/esm/5_client.js

@@ -1,3 +1,4 @@
 export * from "./client/2_client_plain.js";
 export * from "./client/3_types.js";
-export * from "./client/4_client.js";
+export * from "./client/5_client.js";
+export * from "./client/6_composer.js";

package/esm/client/0_utilities.d.ts

@@ -3,3 +3,9 @@ export declare const resolve: () => Promise<void>;
 export type With<T, K extends keyof T> = T & Required<Pick<T, K>>;
 export declare function isPtsUpdate(v: types.TypeUpdate | types.TypeUpdates): v is types.UpdateShortMessage | types.UpdateShortChatMessage | types.UpdateShortSentMessage | types.UpdateNewMessage | types.UpdateDeleteMessages | types.UpdateReadHistoryInbox | types.UpdateReadHistoryOutbox | types.UpdatePinnedChannelMessages | types.UpdatePinnedMessages | types.UpdateFolderPeers | types.UpdateChannelWebPage | types.UpdateEditMessage | types.UpdateReadMessagesContents | types.UpdateWebPage;
 export declare function isChannelPtsUpdate(v: types.TypeUpdate | types.TypeUpdates): v is types.UpdateNewChannelMessage | types.UpdateEditChannelMessage | types.UpdateDeleteChannelMessages;
+/**
+ * Source to a file. Can be a file ID, file path, URL, or `Uint8Array`.
+ */
+export type FileSource = string | URL | Uint8Array;
+export declare function getFileContents(source: FileSource, fileName?: string): Promise<readonly [Uint8Array, string]>;
+export declare function isHttpUrl(string: string): boolean;

package/esm/client/0_utilities.js

@@ -1,3 +1,6 @@
+import * as dntShim from "../_dnt.shims.js";
+import { path } from "../0_deps.js";
+import { UNREACHABLE } from "../1_utilities.js";
 import { types } from "../2_tl.js";
 export const resolve = () => Promise.resolve();
 export function isPtsUpdate(v) {
@@ -21,3 +24,53 @@ export function isChannelPtsUpdate(v) {
         v instanceof types.UpdateEditChannelMessage ||
         v instanceof types.UpdateDeleteChannelMessages;
 }
+export async function getFileContents(source, fileName = "") {
+    fileName = fileName.trim() || "file";
+    let contents;
+    if (source instanceof Uint8Array) {
+        contents = source;
+    }
+    else {
+        let url;
+        try {
+            url = new URL(source).toString();
+        }
+        catch {
+            if (typeof source === "string") {
+                let path_;
+                if (path.isAbsolute(source)) {
+                    path_ = source;
+                }
+                else {
+                    // @ts-ignore: lib
+                    path_ = path.join(dntShim.Deno.cwd(), source);
+                }
+                url = path.toFileUrl(path_).toString();
+                fileName = path.basename(path_);
+            }
+            else {
+                UNREACHABLE();
+            }
+        }
+        const res = await fetch(url);
+        if (fileName == "file") {
+            const contentType = res.headers.get("content-type");
+            if (contentType?.includes("image/png")) {
+                fileName += ".png";
+            }
+            else if (contentType?.includes("image/jpeg")) {
+                fileName += ".jpg";
+            }
+        }
+        contents = await res.arrayBuffer().then((v) => new Uint8Array(v));
+    }
+    return [contents, fileName];
+}
+export function isHttpUrl(string) {
+    try {
+        return new URL(string).protocol.startsWith("http");
+    }
+    catch {
+        return false;
+    }
+}

package/esm/client/3_types.d.ts

@@ -37,7 +37,10 @@ export interface ClientParams extends ClientPlainParams {
      * Whether to automatically call `start` with no parameters in the first `invoke` call. Defaults to `true`.
      */
     autoStart?: boolean;
-    errorHandler?: (err: unknown, function_: types.Type | functions.Function<unknown>, n: number) => MaybePromise<boolean>;
+    /**
+     * Whether to use default handlers. Defaults to `true`.
+     */
+    defaultHandlers?: boolean;
 }
 export interface AnswerCallbackQueryParams {
     /** A text to be shown to the user. */
@@ -54,7 +57,7 @@ export interface AuthorizeUserParams<S = string> {
     code: S | (() => MaybePromise<S>);
     password: S | ((hint: string | null) => MaybePromise<S>);
 }
-export interface SendMessagesParams {
+export interface SendMessageParams {
     /**
      * The parse mode to use. If not provided, the default parse mode will be used.
      */
@@ -223,10 +226,68 @@ export interface SetMyCommandsParams {
     scope?: BotCommandScope;
 }
 export type GetMyCommandsParams = SetMyCommandsParams;
+export interface DeleteMessagesParams {
+    /** Whether to delete the messages only for this side. */
+    onlyForMe?: boolean;
+}
+export interface DeleteMessageParams {
+    /** Whether to delete the message only for this side. */
+    onlyForMe?: boolean;
+}
+export interface SendPhotoParams {
+    /** The file name to assign. */
+    fileName?: string;
+    /** Size of each upload chunk in bytes. */
+    chunkSize?: number;
+    /** Upload abort signal. */
+    signal?: AbortSignal | null;
+    /** The caption of the photo. */
+    caption?: string;
+    /**
+     * The caption's entities.
+     */
+    captionEntities?: MessageEntity[];
+    /**
+     * The parse mode to use for the caption. If not provided, the default parse mode will be used.
+     */
+    parseMode?: ParseMode;
+    /**
+     * Whether to mark the photo as a spoiler.
+     */
+    hasSpoiler?: boolean;
+    /**
+     * Whether to send the message in a silent way without making a sound on the recipients' clients.
+     */
+    disableNotification?: boolean;
+    /**
+     * Whether to protect the contents of the message from copying and forwarding.
+     */
+    protectContent?: boolean;
+    /**
+     * The identifier of a message to reply to.
+     */
+    replyToMessageId?: number;
+    /**
+     * The identifier of a thread to send the message to.
+     */
+    messageThreadId?: number;
+    /**
+     * The identifier of the chat to send the message on behalf of. User-only.
+     */
+    sendAs?: ChatID;
+    /**
+     * The reply markup of the message. Bot-only.
+     */
+    replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
+}
 export type ConnectionState = "notConnected" | "updating" | "ready";
 export type AuthorizationState = {
     authorized: boolean;
 };
+export interface ReplyParams {
+    /** Whether to quote the message that is to be replied. Enabled by default for non-private chats. */
+    quote?: boolean;
+}
 export type FilterableUpdates = "message" | "editedMessage" | "callbackQuery";
 export interface Update {
     message?: Message;
@@ -237,11 +298,18 @@ export interface Update {
     callbackQuery?: CallbackQuery;
     inlineQuery?: InlineQuery;
 }
-export type NextFn = () => Promise<void>;
-export interface Handler<U extends Partial<Update> = Partial<Update>> {
-    (update: U, next: NextFn): MaybePromise<void>;
+export type NextFn<T = void> = () => Promise<T>;
+export interface Handler<C> {
+    (ctx: C, next: NextFn): MaybePromise<void>;
+}
+export interface InvokeErrorHandler<C> {
+    (ctx: {
+        client: C;
+        error: unknown;
+        function: types.Type | functions.Function<unknown>;
+        n: number;
+    }, next: NextFn<boolean>): MaybePromise<boolean>;
 }
-export type FilterUpdate<U extends Update, T extends keyof U, F extends keyof NonNullable<U[T]>> = With<U, T> & Pick<{
-    [P in T]-?: With<NonNullable<U[T]>, F>;
+export type FilterUpdate<U extends Update, T extends keyof U, F extends (keyof NonNullable<U[T]>) | null> = With<U, T> & Pick<{
+    [P in T]-?: F extends keyof NonNullable<U[T]> ? With<NonNullable<U[T]>, F> : NonNullable<U[T]>;
 }, T>;
-export declare const skip: Handler;

package/esm/client/3_types.js

@@ -1 +1 @@
-export const skip = (__, _) => _();
+export {};

package/esm/client/4_composer.d.ts

@@ -0,0 +1,22 @@
+import { FilterableUpdates, FilterUpdate, Update } from "./3_types.js";
+type MaybePromise<T> = T | Promise<T>;
+export type NextFunction = () => Promise<void>;
+export type MiddlewareFn<C extends Update = Update> = (ctx: C, next: NextFunction) => MaybePromise<unknown>;
+export interface MiddlewareObj<C extends Update = Update> {
+    middleware: () => MiddlewareFn<C>;
+}
+export type Middleware<C extends Update = Update> = MiddlewareFn<C> | MiddlewareObj<C>;
+export declare function flatten<C extends Update = Update>(mw: Middleware<C>): MiddlewareFn<C>;
+export declare function concat<C extends Update = Update>(left: MiddlewareFn<C>, right: MiddlewareFn<C>): MiddlewareFn<C>;
+export declare const skip: MiddlewareFn;
+export declare class Composer<C extends Update> implements MiddlewareObj<C> {
+    #private;
+    constructor(...middleware: Middleware<C>[]);
+    middleware(): MiddlewareFn<C>;
+    use(...middleware: Middleware<C>[]): Composer<C>;
+    branch(predicate: (ctx: C) => MaybePromise<boolean>, trueHandler_: Middleware<C>, falseHandler_: Middleware<C>): Composer<C>;
+    filter<D extends C>(predicate: (ctx: C) => ctx is D, ...middleware: Middleware<D>[]): Composer<D>;
+    filter(predicate: (ctx: C) => MaybePromise<boolean>, ...middleware: Middleware<C>[]): Composer<C>;
+    on<T extends keyof Update, F extends keyof NonNullable<Update[T]>>(filter: T extends FilterableUpdates ? T | [T, F, ...F[]] : T, ...middleawre: Middleware<FilterUpdate<C, T, F>>[]): Composer<FilterUpdate<C, T, F>>;
+}
+export {};

package/esm/client/4_composer.js

@@ -0,0 +1,81 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Composer_handle;
+export function flatten(mw) {
+    return typeof mw === "function" ? mw : (ctx, next) => mw.middleware()(ctx, next);
+}
+export function concat(left, right) {
+    return async (ctx, next) => {
+        let called = false;
+        await left(ctx, async () => {
+            if (called) {
+                return;
+            }
+            else {
+                called = true;
+                await right(ctx, next);
+            }
+        });
+    };
+}
+export const skip = (_ctx, next) => next();
+export class Composer {
+    constructor(...middleware) {
+        _Composer_handle.set(this, void 0);
+        __classPrivateFieldSet(this, _Composer_handle, middleware.length == 0 ? skip : middleware.map(flatten).reduce(concat), "f");
+    }
+    middleware() {
+        return __classPrivateFieldGet(this, _Composer_handle, "f");
+    }
+    use(...middleware) {
+        const composer = new Composer(...middleware);
+        __classPrivateFieldSet(this, _Composer_handle, concat(__classPrivateFieldGet(this, _Composer_handle, "f"), flatten(composer)), "f");
+        return composer;
+    }
+    branch(predicate, trueHandler_, falseHandler_) {
+        const trueHandler = flatten(trueHandler_);
+        const falseHandler = flatten(falseHandler_);
+        return this.use(async (upd, next) => {
+            if (await predicate(upd)) {
+                await trueHandler(upd, next);
+            }
+            else {
+                await falseHandler(upd, next);
+            }
+        });
+    }
+    filter(predicate, ...middleware) {
+        return this.branch(predicate, middleware.length == 0 ? skip : middleware.map(flatten).reduce(concat), skip);
+    }
+    on(filter, ...middleawre) {
+        const type = typeof filter === "string" ? filter : filter[0];
+        const keys = Array.isArray(filter) ? filter.slice(1) : [];
+        return this.filter((ctx) => {
+            if (type in ctx) {
+                if (keys.length > 0) {
+                    for (const key of keys) {
+                        // deno-lint-ignore ban-ts-comment
+                        // @ts-ignore
+                        if (!(key in ctx[type])) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+            else {
+                return false;
+            }
+        }, ...middleawre);
+    }
+}
+_Composer_handle = new WeakMap();

package/esm/client/{4_client.d.ts → 5_client.d.ts}

@@ -2,19 +2,66 @@ import { MaybePromise } from "../1_utilities.js";
 import { functions, ReadObject, types } from "../2_tl.js";
 import { Storage } from "../3_storage.js";
 import { DC } from "../3_transport.js";
-import { BotCommand, ChatAction, ChatID, InlineQueryResult, Message, ParseMode, User } from "../3_types.js";
+import { BotCommand, CallbackQuery, ChatAction, ChatID, InlineQuery, InlineQueryResult, Message, ParseMode, User } from "../3_types.js";
 import { Migrate } from "../4_errors.js";
-import { With } from "./0_utilities.js";
+import { FileSource, With } from "./0_utilities.js";
 import { ClientAbstract } from "./1_client_abstract.js";
-import { AnswerCallbackQueryParams, AnswerInlineQueryParams, AuthorizeUserParams, ClientParams, DownloadParams, EditMessageParams, FilterableUpdates, FilterUpdate, ForwardMessagesParams, GetMyCommandsParams, Handler, SendMessagesParams, SendPollParams, SetMyCommandsParams, Update, UploadParams } from "./3_types.js";
+import { AnswerCallbackQueryParams, AnswerInlineQueryParams, AuthorizeUserParams, ClientParams, DeleteMessageParams, DeleteMessagesParams, DownloadParams, EditMessageParams, FilterableUpdates, FilterUpdate, ForwardMessagesParams, GetMyCommandsParams, InvokeErrorHandler, ReplyParams, SendMessageParams, SendPhotoParams, SendPollParams, SetMyCommandsParams, Update, UploadParams } from "./3_types.js";
+import { Composer, Middleware } from "./4_composer.js";
 declare const getEntity: unique symbol;
 declare const getStickerSetName: unique symbol;
 export declare const handleMigrationError: unique symbol;
 declare const getMessageWithReply: unique symbol;
+export interface Context extends Update {
+    /** The client that received the update. */
+    client: Client;
+    /** Resolves to `ctx.message ?? ctx.editedMessage ?? ctx.callbackQuery?.message`. */
+    msg: undefined extends this["message"] ? undefined extends this["editedMessage"] ? undefined extends this["callbackQuery"] ? never : this["callbackQuery"] extends With<CallbackQuery, "message"> ? this["callbackQuery"]["message"] : this["callbackQuery"] extends With<CallbackQuery, "inlineMessageId"> ? never : (Message | undefined) : this["editedMessage"] : this["message"];
+    /** Resolves to `effectiveMessage?.chat`. */
+    chat: this["msg"] extends never ? never : this["msg"]["chat"];
+    /** Resolves to `(ctx.message ?? ctx.editedMessage)?.from ?? ctx.callbackQuery?.from ?? ctx.inlineQuery?.from`. */
+    from: this["message"] extends Message ? this["message"]["from"] : this["editedMessage"] extends Message ? this["editedMessage"]["from"] : this["callbackQuery"] extends CallbackQuery ? this["callbackQuery"]["from"] : this["inlineQuery"] extends InlineQuery ? this["inlineQuery"]["from"] : never;
+    /** Resolves to `effectiveMessage?.senderChat`. */
+    senderChat: this["msg"] extends never ? never : this["msg"]["senderChat"];
+    /** Reply the received message with a text message. */
+    reply: (text: string, params?: Omit<SendMessageParams, "replyToMessageId"> & ReplyParams) => Promise<With<Message, "text">>;
+    /** Reply the received message with a poll. */
+    replyPoll: (question: string, options: [string, string, ...string[]], params?: Omit<SendPollParams, "replyToMessageId"> & ReplyParams) => Promise<With<Message, "poll">>;
+    /** Reply the received message with a photo. */
+    replyPhoto: (photo: FileSource, params?: Omit<SendPhotoParams, "replyToMessageId"> & ReplyParams) => Promise<With<Message, "photo">>;
+    /** Delete the received message. */
+    delete: () => Promise<void>;
+    /** Forward the received message. */
+    forward: (to: ChatID, params?: ForwardMessagesParams) => Promise<this["msg"]>;
+    /** Send a chat action to the chat which the message was received from. */
+    sendChatAction: (action: ChatAction, params?: {
+        messageThreadId?: number;
+    }) => Promise<void>;
+    /** Edit a message in the chat which the message was received from. */
+    editMessageText: (messageId: number, text: string, params?: EditMessageParams) => Promise<With<Message, "text">>;
+    /** Answer the received callback query. */
+    answerCallbackQuery: (params?: AnswerCallbackQueryParams) => Promise<void>;
+    /** Answer the received inline query. */
+    answerInlineQuery: (results: InlineQueryResult[], params?: AnswerInlineQueryParams) => Promise<void>;
+    /** Retrieve a single message of the chat which the message was received from. */
+    getMessage: (messageId: number) => Promise<Omit<Message, "replyToMessage"> | null>;
+    /** Retrieve multiple messages of the chat which the message was received from. */
+    getMessages: (messageIds: number[]) => Promise<Omit<Message, "replyToMessage">[]>;
+    /** Forward a message of the chat which the message was received from. */
+    forwardMessage: (to: ChatID, messageId: number, params?: ForwardMessagesParams) => Promise<Message>;
+    /** Forward multiple messages of the chat which the message was received from. */
+    forwardMessages: (to: ChatID, messageIds: number[], params?: ForwardMessagesParams) => Promise<Message[]>;
+    /** Delete a message in the chat which the message was received from. */
+    deleteMessage: (messageId: number, params?: DeleteMessagesParams) => Promise<void>;
+    /** Delete multiple messages in the chat which the message was received from. */
+    deleteMessages: (messageIds: number[], params?: DeleteMessagesParams) => Promise<void>;
+    toJSON: () => Update;
+}
+export declare function skipInvoke<C extends Context>(): InvokeErrorHandler<Client<C>>;
 export declare const restartAuth: unique symbol;
 export declare class ConnectionError extends Error {
 }
-export declare class Client extends ClientAbstract {
+export declare class Client<C extends Context = Context> extends ClientAbstract {
     #private;
     readonly apiId: number | null;
     readonly apiHash: string | null;
@@ -78,8 +125,12 @@ export declare class Client extends ClientAbstract {
      *
      * @param function_ The function to invoke.
      */
-    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
-    invoke<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T, noWait: true): Promise<void>;
+    invoke: {
+        <T extends types.Type | functions.Function<unknown> = functions.Function<unknown>>(function_: T): Promise<T extends functions.Function<unknown> ? T["__R"] : void>;
+        <T_1 extends types.Type | functions.Function<unknown> = functions.Function<unknown>>(function_: T_1, noWait: true): Promise<void>;
+    } & {
+        use: (handler: InvokeErrorHandler<Client<C>>) => void;
+    };
     /**
      * Alias for `invoke` with its second parameter being `true`.
      */
@@ -99,7 +150,7 @@ export declare class Client extends ClientAbstract {
      * @param text The message's text.
      * @returns The sent text message.
      */
-    sendMessage(chatId: ChatID, text: string, params?: SendMessagesParams): Promise<With<Message, "text">>;
+    sendMessage(chatId: ChatID, text: string, params?: SendMessageParams): Promise<With<Message, "text">>;
     /**
      * Edit a message's text.
      *
@@ -229,11 +280,11 @@ export declare class Client extends ClientAbstract {
      * @param results The results to answer with.
      */
     answerInlineQuery(id: string, results: InlineQueryResult[], params?: AnswerInlineQueryParams): Promise<void>;
-    use(handler: Handler): void;
-    branch(predicate: (upd: Update) => MaybePromise<boolean>, trueHandler: Handler, falseHandler: Handler): void;
-    filter<D extends Update>(predicate: (update: Update) => update is D, handler: Handler<D>): void;
-    filter(predicate: (update: Update) => MaybePromise<boolean>, handler: Handler): void;
-    on<T extends keyof Update, F extends keyof NonNullable<Update[T]>>(filter: T extends FilterableUpdates ? T | [T, F, ...F[]] : T, handler: Handler<FilterUpdate<Update, T, F>>): void;
+    use(...middleware: Middleware<C>[]): Composer<C>;
+    branch(predicate: (ctx: C) => MaybePromise<boolean>, trueHandler_: Middleware<C>, falseHandler_: Middleware<C>): Composer<C>;
+    filter<D extends C>(predicate: (ctx: C) => ctx is D, ...middleware: Middleware<D>[]): void;
+    filter(predicate: (ctx: C) => MaybePromise<boolean>, ...middleware: Middleware<C>[]): void;
+    on<T extends keyof Update, F extends keyof NonNullable<Update[T]>>(filter: T extends FilterableUpdates ? T | [T, F, ...F[]] : T, ...middleawre: Middleware<FilterUpdate<C, T, F>>[]): void;
     /**
      * Set the bot's description in the given language. Bot-only.
      *
@@ -285,5 +336,29 @@ export declare class Client extends ClientAbstract {
     getMyShortDescription(params?: {
         languageCode?: string;
     }): Promise<string>;
+    /**
+     * Delete multiple messages.
+     *
+     * @method
+     * @param chatId The chat that contains the messages.
+     * @param messageIds The identifier of the messages to delete.
+     */
+    deleteMessages(chatId: ChatID, messageIds: number[], params?: DeleteMessagesParams): Promise<void>;
+    /**
+     * Delete a single message.
+     *
+     * @method
+     * @param chatId The chat that contains the message.
+     * @param messageId The identifier of the message to delete.
+     */
+    deleteMessage(chatId: ChatID, messageId: number, params?: DeleteMessageParams): Promise<void>;
+    /**
+     * Send a photo.
+     *
+     * @method
+     * @param chatId The chat to send the photo to.
+     * @param photo The photo to send.
+     */
+    sendPhoto(chatId: ChatID, photo: FileSource, params?: SendPhotoParams): Promise<With<Message, "photo">>;
 }
 export {};