@mtkruto/node 0.0.992 → 0.0.994

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 = 161;
-export declare const APP_VERSION = "MTKruto 0.0.992";
+export declare const APP_VERSION = "MTKruto 0.0.994";
 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-test";
 export const LAYER = 161;
-export const APP_VERSION = "MTKruto 0.0.992";
+export const APP_VERSION = "MTKruto 0.0.994";
 // @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,2 +1,3 @@
 export * from "./client/2_client_plain.js";
-export * from "./client/3_client.js";
+export { Composer } from "./client/4_composer.js";
+export * from "./client/5_client.js";

package/esm/5_client.js

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

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

@@ -1,9 +1,9 @@
-import { Message, MessageContainer } from "../2_tl.js";
+import { Message_, MessageContainer } from "../2_tl.js";
 export declare function getMessageId(lastMsgId: bigint): bigint;
 export declare function packUnencryptedMessage(data: Uint8Array, messageId: bigint): Uint8Array;
 export declare function unpackUnencryptedMessage(buffer: Uint8Array): {
     messageId: bigint;
     message: Uint8Array;
 };
-export declare function encryptMessage(message: Message, authKey: Uint8Array, authKeyId: bigint, salt: bigint, sessionId: bigint): Promise<Uint8Array>;
-export declare function decryptMessage(buffer: Uint8Array, authKey: Uint8Array, authKeyId: bigint, _sessionId: bigint): Promise<Message | MessageContainer>;
+export declare function encryptMessage(message: Message_, authKey: Uint8Array, authKeyId: bigint, salt: bigint, sessionId: bigint): Promise<Uint8Array>;
+export declare function decryptMessage(buffer: Uint8Array, authKey: Uint8Array, authKeyId: bigint, _sessionId: bigint): Promise<Message_ | MessageContainer>;

package/esm/client/0_message.js

@@ -1,6 +1,6 @@
 import { assertEquals, ige256Decrypt, ige256Encrypt } from "../0_deps.js";
 import { bufferFromBigInt, concat, sha256 } from "../1_utilities.js";
-import { id, Message, MessageContainer, RPCResult, serialize, TLReader, TLWriter } from "../2_tl.js";
+import { id, Message_, MessageContainer, RPCResult, serialize, TLReader, TLWriter } from "../2_tl.js";
 export function getMessageId(lastMsgId) {
     const now = new Date().getTime() / 1000 + 0;
     const nanoseconds = Math.floor((now - Math.floor(now)) * 1e9);
@@ -80,10 +80,10 @@ export async function decryptMessage(buffer, authKey, authKeyId, _sessionId) {
     }
     else if (cid == RPCResult[id]) {
         const body = RPCResult.deserialize(plainReader.buffer);
-        return new Message(mid, seqno, body);
+        return new Message_(mid, seqno, body);
     }
     else {
         const body = plainReader.readObject(cid);
-        return new Message(mid, seqno, body);
+        return new Message_(mid, seqno, body);
     }
 }

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

@@ -1,3 +1,5 @@
 import { types } from "../2_tl.js";
+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 | types.UpdateReadChannelInbox;

package/esm/client/0_utilities.js

@@ -1,4 +1,5 @@
 import { types } from "../2_tl.js";
+export const resolve = () => Promise.resolve();
 export function isPtsUpdate(v) {
     return v instanceof types.UpdateShortMessage ||
         v instanceof types.UpdateShortChatMessage ||

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

@@ -0,0 +1,221 @@
+import { MaybePromise } from "../1_utilities.js";
+import { CallbackQuery, ForceReply, InlineKeyboardMarkup, InlineQuery, Message, MessageEntity, ReplyKeyboardMarkup, ReplyKeyboardRemove } from "../3_types.js";
+import { With } from "./0_utilities.js";
+import { ClientPlainParams } from "./2_client_plain.js";
+export type ParseMode = "html" | "none";
+export interface ClientParams extends ClientPlainParams {
+    /**
+     * A parse mode to use when the `parseMode` parameter is not specified when sending or editing messages. Defauls to `ParseMode.None`.
+     */
+    parseMode?: ParseMode;
+    /**
+     * The app_version parameter to be passed to initConnection when calling `authorize`. It is recommended that this parameter is changed if users are authorized. Defaults to "MTKruto" followed by this version of MTKruto.
+     */
+    appVersion?: string;
+    /**
+     * The device_version parameter to be passed to initConnection when calling `authorize`. The default varies by the current runtime.
+     */
+    deviceModel?: string;
+    /**
+     * The lang_code parameter to be passed to initConnection when calling `authorize`. Defaults to the runtime's language or `"en"`.
+     */
+    langCode?: string;
+    /**
+     * The lang_pack parameter to be passed to initConnection when calling `authorize`. Defaults to an empty string.
+     */
+    langPack?: string;
+    /**
+     * The system_lang_cde parameter to be passed to initConnection when calling `authorize`. Defaults to the runtime's language or `"en"`.
+     */
+    systemLangCode?: string;
+    /**
+     * The system_version parameter to be passed to initConnection when calling `authorize`. The default varies by the current runtime.
+     */
+    systemVersion?: string;
+    /**
+     * Whether to automatically call `start` with no parameters in the first `invoke` call. Defaults to `true`.
+     */
+    autoStart?: boolean;
+}
+export interface AnswerCallbackQueryParams {
+    /** Text of the answer */
+    text?: string;
+    /** Pass true to show an alert to the user instead of a toast notification */
+    alert?: boolean;
+    /** URL to be opened */
+    url?: string;
+    /** Time during which the result of the query can be cached, in seconds */
+    cacheTime?: number;
+}
+export interface AuthorizeUserParams<S = string> {
+    phone: S | (() => MaybePromise<S>);
+    code: S | (() => MaybePromise<S>);
+    password: S | ((hint: string | null) => MaybePromise<S>);
+}
+/**
+ * A chat identifier as provided by MTKruto or a string starting with a @ that is followed by a username.
+ */
+export type ChatID = number | string;
+export interface SendMessagesParams {
+    /**
+     * The parse mode to use. If not provided, the default parse mode will be used.
+     */
+    parseMode?: ParseMode;
+    /**
+     * The message's entities.
+     */
+    entities?: MessageEntity[];
+    /**
+     * Whether to disable web page previews in the message that is to be sent.
+     */
+    disableWebPagePreview?: 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 interface EditMessageParams {
+    /**
+     * The parse mode to use. If not provided, the default parse mode will be used.
+     */
+    parseMode?: ParseMode;
+    /**
+     * The message's entities.
+     */
+    entities?: MessageEntity[];
+    /**
+     * Whether to disable web page previews in the message that is to be edited.
+     */
+    disableWebPagePreview?: boolean;
+    /**
+     * The reply markup of the message. Bot-only.
+     */
+    replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
+}
+export interface ForwardMessagesParams {
+    messageThreadId?: number;
+    /**
+     * Whether to forward the message in a silent way without making a sound on the recipients' clients.
+     */
+    disableNotification?: boolean;
+    /**
+     * Whether to protect the contents of the forwarded message from copying and forwarding.
+     */
+    protectContent?: boolean;
+    /**
+     * The identifier of the chat to forward the message on behalf of. User-only.
+     */
+    sendAs?: ChatID;
+    /**
+     * Whether to not include the original sender of the message that is going to be forwarded.
+     */
+    dropSenderName?: boolean;
+    /**
+     * Whether to not include the original caption of the message that is going to be forwarded.
+     */
+    dropCaption?: boolean;
+}
+export interface SendPollParams {
+    /**
+     * True, if the poll needs to be anonymous, defaults to True */
+    isAnonymous?: boolean;
+    /**
+     * The type of the poll. Defaults to regular. */
+    type?: "quiz" | "regular";
+    /**
+     * True, if the poll allows multiple answers, ignored for polls in quiz mode, defaults to False */
+    allowMultipleAnswers?: boolean;
+    /**
+     * Index of the correct option. Required for quizzes. */
+    correctOptionIndex?: number;
+    /**
+     *  Text that is shown when a user chooses an incorrect answer or taps on the lamp icon in a quiz-style poll, 0-200 characters with at most 2 line feeds after entities parsing */
+    explanation?: string;
+    /**
+     * The parse mode to use for the explanation. If not provided, the default parse mode will be used.
+     */
+    explanationParseMode?: ParseMode;
+    /**
+     * The explanation's entities.
+     */
+    explanationEntities?: MessageEntity[];
+    /**
+     * Amount of time in seconds the poll will be active after creation, 5-600. Can't be used together with close_date.
+     */
+    openPeriod?: number;
+    /**
+     * Point in time when the poll will be automatically closed. Must be at least 5 and no more than 600 seconds in the future. Can't be used together with open_period.
+     */
+    closeDate?: Date;
+    /**
+     * Pass True if the poll needs to be immediately closed. This can be useful for poll preview.
+     */
+    isClosed?: boolean;
+    /**
+     * Whether to send the message in a silent way without making a sound on the recipients' clients.
+     */
+    disableNotification?: 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;
+    /**
+     * Whether to protect the contents of the message from copying and forwarding.
+     */
+    protectContent?: boolean;
+}
+export type ConnectionState = "not-connected" | "updating" | "ready";
+export type AuthorizationState = {
+    authorized: boolean;
+};
+export type FilterableUpdates = "message" | "editedMessage" | "callbackQuery";
+export interface Update {
+    message?: Message;
+    editedMessage?: Message;
+    connectionState?: ConnectionState;
+    authorizationState?: AuthorizationState;
+    deletedMessages?: [Message, ...Message[]];
+    callbackQuery?: CallbackQuery;
+    inlineQuery?: InlineQuery;
+}
+export type NextFn = () => Promise<void>;
+export interface HandlerObj<U extends Partial<Update> = Partial<Update>> {
+    handle(update: U, next: NextFn): MaybePromise<void>;
+}
+export type HandlerFn<U extends Partial<Update> = Partial<Update>> = HandlerObj<U>["handle"];
+export type Handler<U extends Partial<Update> = Partial<Update>> = HandlerObj<U> | HandlerFn<U>;
+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>;
+}, T>;

package/esm/client/3_types.js

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

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

@@ -0,0 +1,13 @@
+import { MaybePromise } from "../1_utilities.js";
+import { FilterableUpdates, FilterUpdate, Handler, HandlerFn, HandlerObj, Update } from "./3_types.js";
+export declare function call(handler: Handler): HandlerFn;
+export declare class Composer<U extends Update = Update> implements HandlerObj<U> {
+    constructor(...handlers: Handler<U>[]);
+    get handle(): HandlerFn;
+    private _handle;
+    use(...handlers: Handler<U>[]): this;
+    branch(predicate: (upd: U) => MaybePromise<boolean>, trueHandler: Handler<U>, falseHandler: Handler<U>): this;
+    filter<D extends U>(predicate: (ctx: U) => ctx is D, ...middleware: Handler<D>[]): Composer<D>;
+    filter(predicate: (ctx: U) => MaybePromise<boolean>, ...middleware: Handler<U>[]): Composer<U>;
+    on<T extends keyof U, F extends keyof NonNullable<U[T]>>(filter: T extends FilterableUpdates ? T | [T, F, ...F[]] : T, ...handlers: Handler<FilterUpdate<U, T, F>>[]): Composer<FilterUpdate<U, T, F>>;
+}

package/esm/client/4_composer.js

@@ -0,0 +1,80 @@
+import { resolve } from "./0_utilities.js";
+export function call(handler) {
+    if ("handle" in handler) {
+        return handler.handle;
+    }
+    else {
+        return handler;
+    }
+}
+function concat(what, with_) {
+    return async (upd, next) => {
+        let called = false;
+        await call(what)(upd, async () => {
+            if (called)
+                return;
+            called = true;
+            await call(with_)(upd, next);
+        });
+    };
+}
+function reduce(...handlers) {
+    return handlers.reduce((a, b) => concat(a, b));
+}
+export class Composer {
+    constructor(...handlers) {
+        Object.defineProperty(this, "_handle", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: resolve
+        });
+        this.use(...handlers);
+    }
+    get handle() {
+        return this._handle;
+    }
+    use(...handlers) {
+        const handle = this.handle;
+        this._handle = concat(handle, reduce(...handlers));
+        return this;
+    }
+    branch(predicate, trueHandler, falseHandler) {
+        return this.use(async (upd, next) => {
+            if (await predicate(upd)) {
+                await call(trueHandler)(upd, next);
+            }
+            else {
+                await call(falseHandler)(upd, next);
+            }
+        });
+    }
+    filter(predicate, ...middleware) {
+        const composer = new Composer(...middleware);
+        this.branch(predicate, composer, resolve);
+        return composer;
+    }
+    on(filter, ...handlers) {
+        // deno-lint-ignore ban-ts-comment
+        // @ts-ignore
+        const type = typeof filter === "string" ? filter : filter[0];
+        const keys = Array.isArray(filter) ? filter.slice(1) : [];
+        return this.filter((update) => {
+            if (type in update) {
+                if (keys.length > 0) {
+                    for (const key of keys) {
+                        // deno-lint-ignore ban-ts-comment
+                        // @ts-ignore
+                        if (!(key in update[type])) {
+                            return false;
+                        }
+                    }
+                }
+                return true;
+            }
+            else {
+                return false;
+            }
+        }, ...handlers);
+    }
+}

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

@@ -1,152 +1,15 @@
-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 { CallbackQuery, ForceReply, InlineKeyboardMarkup, InlineQuery, Message, // high-level Telegram API message
-MessageEntity, ReplyKeyboardMarkup, ReplyKeyboardRemove } from "../3_types.js";
-import { ClientPlainParams } from "./2_client_plain.js";
+import { Message } from "../3_types.js";
+import { With } from "./0_utilities.js";
 import { ClientAbstract } from "./1_client_abstract.js";
+import { AnswerCallbackQueryParams, AuthorizeUserParams, ChatID, ClientParams, EditMessageParams, ForwardMessagesParams, Handler, ParseMode, SendMessagesParams, SendPollParams } from "./3_types.js";
 export declare const getEntity: unique symbol;
 export declare const getStickerSetName: unique symbol;
 export declare const handleMigrationError: unique symbol;
 export declare const getMessageWithReply: unique symbol;
 export declare const restartAuth: unique symbol;
-export declare enum ParseMode {
-    None = "none",
-    HTML = "html"
-}
-export interface AuthorizeUserParams<S = string> {
-    phone: S | (() => MaybePromise<S>);
-    code: S | (() => MaybePromise<S>);
-    password: S | ((hint: string | null) => MaybePromise<S>);
-}
-export interface ClientParams extends ClientPlainParams {
-    /**
-     * A parse mode to use when the `parseMode` parameter is not specified when sending or editing messages. Defauls to `ParseMode.None`.
-     */
-    parseMode?: ParseMode;
-    /**
-     * The app_version parameter to be passed to initConnection when calling `authorize`. It is recommended that this parameter is changed if users are authorized. Defaults to "MTKruto" followed by this version of MTKruto.
-     */
-    appVersion?: string;
-    /**
-     * The device_version parameter to be passed to initConnection when calling `authorize`. The default varies by the current runtime.
-     */
-    deviceModel?: string;
-    /**
-     * The lang_code parameter to be passed to initConnection when calling `authorize`. Defaults to the runtime's language or `"en"`.
-     */
-    langCode?: string;
-    /**
-     * The lang_pack parameter to be passed to initConnection when calling `authorize`. Defaults to an empty string.
-     */
-    langPack?: string;
-    /**
-     * The system_lang_cde parameter to be passed to initConnection when calling `authorize`. Defaults to the runtime's language or `"en"`.
-     */
-    systemLangCode?: string;
-    /**
-     * The system_version parameter to be passed to initConnection when calling `authorize`. The default varies by the current runtime.
-     */
-    systemVersion?: string;
-    /**
-     * Whether to automatically call `start` with no parameters in the first `invoke` call. Defaults to `true`.
-     */
-    autoStart?: boolean;
-}
-export interface AnswerCallbackQueryParams {
-    /** Text of the answer */
-    text?: string;
-    /** Pass true to show an alert to the user instead of a toast notification */
-    alert?: boolean;
-    /** URL to be opened */
-    url?: string;
-    /** Time during which the result of the query can be cached, in seconds */
-    cacheTime?: number;
-}
-/**
- * A chat identifier as provided by MTKruto or a string starting with a @ that is followed by a username.
- */
-export type ChatID = number | string;
-export interface SendMessagesParams {
-    /**
-     * The parse mode to use. If not provided, the default parse mode will be used.
-     */
-    parseMode?: ParseMode;
-    /**
-     * The message's entities.
-     */
-    entities?: MessageEntity[];
-    /**
-     * Whether to disable web page previews in the message that is to be sent.
-     */
-    disableWebPagePreview?: 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 interface EditMessageParams {
-    /**
-     * The parse mode to use. If not provided, the default parse mode will be used.
-     */
-    parseMode?: ParseMode;
-    /**
-     * The message's entities.
-     */
-    entities?: MessageEntity[];
-    /**
-     * Whether to disable web page previews in the message that is to be edited.
-     */
-    disableWebPagePreview?: boolean;
-    /**
-     * The reply markup of the message. Bot-only.
-     */
-    replyMarkup?: InlineKeyboardMarkup | ReplyKeyboardMarkup | ReplyKeyboardRemove | ForceReply;
-}
-export interface ForwardMessagesParams {
-    messageThreadId?: number;
-    /**
-     * Whether to forward the message in a silent way without making a sound on the recipients' clients.
-     */
-    disableNotification?: boolean;
-    /**
-     * Whether to protect the contents of the forwarded message from copying and forwarding.
-     */
-    protectContent?: boolean;
-    /**
-     * The identifier of the chat to forward the message on behalf of. User-only.
-     */
-    sendAs?: ChatID;
-    /**
-     * Whether to not include the original sender of the message that is going to be forwarded.
-     */
-    dropSenderName?: boolean;
-    /**
-     * Whether to not include the original caption of the message that is going to be forwarded.
-     */
-    dropCaption?: boolean;
-}
 export declare class Client extends ClientAbstract {
     readonly storage: Storage;
     readonly apiId: number | null;
@@ -194,6 +57,8 @@ export declare class Client extends ClientAbstract {
      * Before establishing the connection, the session is saved.
      */
     connect(): Promise<void>;
+    private assertUser;
+    private assertBot;
     private fetchState;
     [handleMigrationError](err: types.RPCError): Promise<void>;
     private connectionInited;
@@ -259,13 +124,15 @@ export declare class Client extends ClientAbstract {
     [getEntity](peer: types.PeerChannel): Promise<types.Channel | null>;
     processResult(result: ReadObject): Promise<void>;
     private updatesToMessages;
+    private resolveSendAs;
     /**
      * Send a text message.
      *
      * @param chatId The chat to send the message to.
      * @param text The message's text.
      */
-    sendMessage(chatId: ChatID, text: string, params?: SendMessagesParams): Promise<Message>;
+    sendMessage(chatId: ChatID, text: string, params?: SendMessagesParams): Promise<With<Message, "text">>;
+    private parseText;
     /**
      * Edit a message's text.
      *
@@ -319,34 +186,22 @@ export declare class Client extends ClientAbstract {
      */
     getMe(): Promise<import("../3_types.js").User>;
     private handleUpdate;
-    handler: Handler;
-    use(middleware: Handler): void;
-    on<U extends keyof Update, K extends keyof Update[U]>(filter: U extends FilterableUpdates ? U | [U, K, ...K[]] : U, handler: Handler<Pick<{
-        [P in U]: With<Update[U], K>;
-    }, U>>): void;
+    private _handler;
+    set handler(handler: Handler);
     /**
      * Answer a callback query. Bot-only.
      *
      * @param id ID of the callback query to answer.
      */
     answerCallbackQuery(id: string, params?: AnswerCallbackQueryParams): Promise<void>;
+    private constructReplyMarkup;
+    private static assertMsgHas;
+    /**
+     * Send a poll.
+     *
+     * @param chatId The chat to send the poll to.
+     * @param question The poll's question.
+     * @param options The poll's options.
+     */
+    sendPoll(chatId: ChatID, question: string, options: [string, string, ...string[]], params?: SendPollParams): Promise<With<Message, "poll">>;
 }
-type With<T, K extends keyof T> = T & Required<Pick<T, K>>;
-export type ConnectionState = "not-connected" | "updating" | "ready";
-export type AuthorizationState = {
-    authorized: boolean;
-};
-type FilterableUpdates = "message" | "editedMessage" | "callbackQuery";
-export interface Update {
-    message: Message;
-    editedMessage: Message;
-    connectionState: ConnectionState;
-    authorizationState: AuthorizationState;
-    deletedMessages: [Message, ...Message[]];
-    callbackQuery: CallbackQuery;
-    inlineQuery: InlineQuery;
-}
-export interface Handler<U extends Partial<Update> = Partial<Update>> {
-    (update: U, next: () => Promise<void>): MaybePromise<void>;
-}
-export {};