@mtkruto/node 0.0.993 → 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.993";
+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.993";
+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/5_client.d.ts

@@ -0,0 +1,207 @@
+import { functions, ReadObject, types } from "../2_tl.js";
+import { Storage } from "../3_storage.js";
+import { DC } from "../3_transport.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 class Client extends ClientAbstract {
+    readonly storage: Storage;
+    readonly apiId: number | null;
+    readonly apiHash: string | null;
+    private auth;
+    private sessionId;
+    private state;
+    private promises;
+    private toAcknowledge;
+    private updateState?;
+    readonly parseMode: ParseMode;
+    readonly appVersion: string;
+    readonly deviceModel: string;
+    readonly langCode: string;
+    readonly langPack: string;
+    readonly systemLangCode: string;
+    readonly systemVersion: string;
+    private readonly publicKeys?;
+    private readonly autoStart;
+    /**
+     * Constructs the client.
+     *
+     * @param storage The storage provider to use. Defaults to memory storage.
+     * @param apiId App's API ID from [my.telegram.org](https://my.telegram.org/apps). Defaults to 0 (unset).
+     * @param apiHash App's API hash from [my.telegram.org/apps](https://my.telegram.org/apps). Defaults to empty string (unset).
+     * @param params Other parameters.
+     */
+    constructor(storage?: Storage, apiId?: number | null, apiHash?: string | null, params?: ClientParams);
+    private propagateConnectionState;
+    private lastPropagatedConnectionState;
+    protected stateChangeHandler: (connected: boolean) => void;
+    private storageInited;
+    /**
+     * Sets the DC and resets the auth key stored in the session provider
+     * if the stored DC was not the same as the `dc` parameter.
+     *
+     * @param dc The DC to change to.
+     */
+    setDc(dc: DC): Promise<void>;
+    private setAuth;
+    private connectMutex;
+    /**
+     * Loads the session if `setDc` was not called, initializes and connnects
+     * a `ClientPlain` to generate auth key if there was none, and connects the client.
+     * 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;
+    disconnect(): Promise<void>;
+    private initConnection;
+    private lastPropagatedAuthorizationState;
+    private propagateAuthorizationState;
+    /**
+     * Calls [initConnection](1) and authorizes the client with one of the following:
+     *
+     * - Bot token (`string`)
+     * - Exported authorization (`types.AuthExportedAuthorization`)
+     * - User authorization handlers (`AuthorizeUserParams`)
+     *
+     * if the current auth key doesn't throw AUTH_KEY_UNREGISTERED when calling [updates.getState](2).
+     *
+     * Notes:
+     * 1. Requires the `apiId` and `apiHash` paramters to be passed when constructing the client.
+     * 2. Reconnects the client to the appropriate DC in case of MIGRATE_X errors.
+     * 3. The parameters passed to the [initConnection][1] call can be configured with the last parameter of the constructor.
+     *
+     * [1]: https://core.telegram.org/method/initConnection
+     * [2]: https://core.telegram.org/method/updates.getState
+     */
+    authorize(params?: string | types.AuthExportedAuthorization | AuthorizeUserParams): Promise<void>;
+    /**
+     * Same as calling `.connect()` followed by `.authorize(params)`.
+     */
+    start(params?: string | types.AuthExportedAuthorization | AuthorizeUserParams): Promise<void>;
+    private receiveLoop;
+    private pingLoop;
+    private autoStarted;
+    private lastMsgId;
+    /**
+     * Invokes a function waiting and returning its reply if the second parameter is not `true`. Requires the client
+     * to be connected.
+     *
+     * @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>;
+    /**
+     * Alias for `invoke` with its second parameter being `true`.
+     */
+    send<T extends (functions.Function<unknown> | types.Type) = functions.Function<unknown>>(function_: T): Promise<void>;
+    private processChats;
+    private processUsers;
+    private handleUpdateQueue;
+    private processUpdatesQueue;
+    private checkGap;
+    private checkChannelGap;
+    private processUpdates;
+    private setUpdateStateDate;
+    private getLocalState;
+    private recoverUpdateGap;
+    private recoverChannelUpdateGap;
+    private getUserAccessHash;
+    private getChannelAccessHash;
+    getInputPeer(id: ChatID): Promise<types.InputPeerChat | types.InputPeerUser | types.InputPeerChannel>;
+    private getInputPeerInner;
+    [getEntity](peer: types.PeerUser): Promise<types.User | null>;
+    [getEntity](peer: types.PeerChat): Promise<types.Chat | null>;
+    [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<With<Message, "text">>;
+    private parseText;
+    /**
+     * Edit a message's text.
+     *
+     * @param chatId The chat where the message is.
+     * @param messageId The ID of the message.
+     * @param text The new text of the message.
+     */
+    editMessageText(chatId: ChatID, messageId: number, text: string, params?: EditMessageParams): Promise<void>;
+    private getMessagesInner;
+    /**
+     * Retrieve multiple messages.
+     *
+     * @param chatId The identifier of the chat to retrieve the messages from.
+     * @param messageIds The identifiers of the messages to retrieve.
+     */
+    getMessages(chatId_: ChatID, messageIds: number[]): Promise<Omit<Message, "replyToMessage">[]>;
+    [getMessageWithReply](chatId: ChatID, messageId: number): Promise<Message | null>;
+    /**
+     * Retrieve a single message.
+     *
+     * @param chatId The identifier of the chat to retrieve the message from.
+     * @param messageId The identifier of the message to retrieve.
+     */
+    getMessage(chatId: ChatID, messageId: number): Promise<Omit<Message, "replyToMessage"> | null>;
+    private downloadInner;
+    /**
+     * Download a file.
+     *
+     * @param fileId The identifier of the file to download.
+     */
+    download(fileId: string): Promise<AsyncGenerator<Uint8Array, void, unknown>>;
+    [getStickerSetName](inputStickerSet: types.InputStickerSetID, hash?: number): Promise<string>;
+    /**
+     * Forward multiple messages.
+     *
+     * @param from The identifier of the chat to forward the messages from.
+     * @param to The identifier of the chat to forward the messages to.
+     * @param messageIds The identifiers of the messages to forward.
+     */
+    forwardMessages(from: ChatID, to: ChatID, messageIds: number[], params?: ForwardMessagesParams): Promise<Message[]>;
+    /**
+     * Forward a single message.
+     *
+     * @param from The identifier of the chat to forward the message from.
+     * @param to The identifier of the chat to forward the message to.
+     * @param messageId The identifier of the message to forward.
+     */
+    forwardMessage(from: ChatID, to: ChatID, messageId: number, params?: ForwardMessagesParams): Promise<Message>;
+    /**
+     * Get information on the currently authorized user.
+     */
+    getMe(): Promise<import("../3_types.js").User>;
+    private handleUpdate;
+    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">>;
+}