@mtcute/core 0.18.0-rc.5 → 0.18.0

package/highlevel/client.types.d.cts

@@ -0,0 +1,61 @@
+import { Emitter } from '@fuman/utils';
+import { tl } from '@mtcute/tl';
+import { default as Long } from 'long';
+import { ConnectionKind, RpcCallOptions } from '../network/index.js';
+import { ICorePlatform } from '../types/platform.js';
+import { MustEqual, PublicPart } from '../types/utils.js';
+import { Logger } from '../utils/logger.js';
+import { AppConfigManager } from './managers/app-config-manager.js';
+import { TimersManager } from './managers/timers.js';
+import { TelegramStorageManager } from './storage/storage.js';
+import { RawUpdateInfo } from './updates/types.js';
+import { InputStringSessionData } from './utils/string-session.js';
+/**
+ * Connection state of the client
+ *
+ * - `offline` - not connected (only emitted when {@link ICorePlatform.onNetworkChanged} callback
+ *   is called with `false`)
+ * - `connecting` - currently connecting. All requests will be queued until the connection is established
+ * - `updating` - connected and is currently updating the state (i.e. downloading missing updates).
+ *   At this point client is already fully operational, but some updates may be missing.
+ *   Is only emitted when updates manager is enabled.
+ * - `connected` - connected and ready to send requests. When updates manager is enabled, this state
+ *   may be emitted before `updating` state
+ */
+export type ConnectionState = 'offline' | 'connecting' | 'updating' | 'connected';
+export interface ITelegramClient {
+    readonly log: Logger;
+    readonly storage: PublicPart<TelegramStorageManager>;
+    readonly appConfig: PublicPart<AppConfigManager>;
+    readonly timers: Pick<TimersManager, 'create' | 'cancel' | 'exists'>;
+    readonly stopSignal: AbortSignal;
+    readonly platform: ICorePlatform;
+    prepare(): Promise<void>;
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    notifyLoggedIn(auth: tl.auth.TypeAuthorization | tl.RawUser): Promise<tl.RawUser>;
+    notifyLoggedOut(): Promise<void>;
+    notifyChannelOpened(channelId: number, pts?: number): Promise<boolean>;
+    notifyChannelClosed(channelId: number): Promise<boolean>;
+    startUpdatesLoop(): Promise<void>;
+    stopUpdatesLoop(): Promise<void>;
+    call<T extends tl.RpcMethod>(message: MustEqual<T, tl.RpcMethod>, params?: RpcCallOptions): Promise<tl.RpcCallReturn[T['_']]>;
+    importSession(session: string | InputStringSessionData, force?: boolean): Promise<void>;
+    exportSession(): Promise<string>;
+    handleClientUpdate(updates: tl.TypeUpdates, noDispatch?: boolean): void;
+    onServerUpdate: Emitter<tl.TypeUpdates>;
+    onRawUpdate: Emitter<RawUpdateInfo>;
+    onConnectionState: Emitter<ConnectionState>;
+    onError: Emitter<Error>;
+    getApiCrenetials(): Promise<{
+        id: number;
+        hash: string;
+    }>;
+    getPoolSize(kind: ConnectionKind, dcId?: number): Promise<number>;
+    getPrimaryDcId(): Promise<number>;
+    changePrimaryDc(newDc: number): Promise<void>;
+    computeSrpParams(request: tl.account.RawPassword, password: string): Promise<tl.RawInputCheckPasswordSRP>;
+    computeNewPasswordHash(algo: tl.TypePasswordKdfAlgo, password: string): Promise<Uint8Array>;
+    getMtprotoMessageId(): Promise<Long>;
+    recreateDc(dcId: number): Promise<void>;
+}

package/highlevel/index.d.cts

@@ -0,0 +1,4 @@
+export * from './client.types.js';
+export * from './storage/index.js';
+export * from './types/index.js';
+export * from './updates/index.js';

package/highlevel/managers/app-config-manager.d.cts

@@ -0,0 +1,11 @@
+import { BaseTelegramClient } from '../base.js';
+import { AppConfigSchema } from '../types/misc/app-config.js';
+export declare class AppConfigManager {
+    private client;
+    private _resource;
+    constructor(client: BaseTelegramClient);
+    private _object?;
+    get(): Promise<AppConfigSchema>;
+    getField<K extends keyof AppConfigSchema>(field: K): Promise<AppConfigSchema[K]>;
+    getField<K extends keyof AppConfigSchema>(field: K, fallback: NonNullable<AppConfigSchema[K]>): Promise<NonNullable<AppConfigSchema[K]>>;
+}

package/highlevel/managers/timers.d.cts

@@ -0,0 +1,10 @@
+export declare class TimersManager {
+    private _timers;
+    private _errorHandler?;
+    constructor();
+    exists(key: string): boolean;
+    create(key: string, handler: (abortSignal: AbortSignal) => Promise<void>, interval: number, startNow?: boolean): void;
+    cancel(key: string): void;
+    onError(handler: (err: unknown) => void): void;
+    destroy(): void;
+}

package/highlevel/methods/_imports.d.cts

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

package/highlevel/methods/_init.d.cts

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

package/highlevel/methods/auth/check-password.d.cts

@@ -0,0 +1,10 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/index.js';
+/**
+ * Check your Two-Step verification password and log in
+ *
+ * @param password  Your Two-Step verification password
+ * @returns  The authorized user
+ * @throws BadRequestError  In case the password is invalid
+ */
+export declare function checkPassword(client: ITelegramClient, password: string): Promise<User>;

package/highlevel/methods/auth/get-password-hint.d.cts

@@ -0,0 +1,7 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Get your Two-Step Verification password hint.
+ *
+ * @returns  The password hint as a string, if any
+ */
+export declare function getPasswordHint(client: ITelegramClient): Promise<string | null>;

package/highlevel/methods/auth/log-out.d.cts

@@ -0,0 +1,17 @@
+import { ITelegramClient } from '../../client.types.js';
+export interface LogOutResult {
+    /**
+     * Future auth token returned by the server (if any), which can then be passed to
+     * {@link start} and {@link sendCode} methods to avoid sending the code again.
+     */
+    futureAuthToken?: Uint8Array;
+}
+/**
+ * Log out from Telegram account and optionally reset the session storage.
+ *
+ * When you log out, you can immediately log back in using
+ * the same {@link TelegramClient} instance.
+ *
+ * @returns  On success, `true` is returned
+ */
+export declare function logOut(client: ITelegramClient): Promise<LogOutResult>;

package/highlevel/methods/auth/recover-password.d.cts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/index.js';
+/**
+ * Recover your password with a recovery code and log in.
+ *
+ * @returns  The authorized user
+ * @throws BadRequestError  In case the code is invalid
+ */
+export declare function recoverPassword(client: ITelegramClient, params: {
+    /** The recovery code sent via email */
+    recoveryCode: string;
+}): Promise<User>;

package/highlevel/methods/auth/resend-code.d.cts

@@ -0,0 +1,16 @@
+import { ITelegramClient } from '../../client.types.js';
+import { SentCode } from '../../types/auth/sent-code.js';
+/**
+ * Re-send the confirmation code using a different type.
+ *
+ * The type of the code to be re-sent is specified in the `nextType` attribute of
+ * {@link SentCode} object returned by {@link sendCode}
+ */
+export declare function resendCode(client: ITelegramClient, params: {
+    /** Phone number in international format */
+    phone: string;
+    /** Confirmation code identifier from {@link SentCode} */
+    phoneCodeHash: string;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+}): Promise<SentCode>;

package/highlevel/methods/auth/run.d.cts

@@ -0,0 +1,16 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/index.js';
+import { start } from './start.js';
+/**
+ * Simple wrapper that calls {@link start} and then
+ * provided callback function (if any) without the
+ * need to introduce a `main()` function manually.
+ *
+ * Errors that were encountered while calling {@link start}
+ * and `then` will be emitted as usual, and can be caught with {@link onError}
+ *
+ * @param params  Parameters to be passed to {@link start}
+ * @param then  Function to be called after {@link start} returns
+ * @deprecated  This method provides no real value over {@link start}, please use it instead
+ */
+export declare function run(client: ITelegramClient, params: Parameters<typeof start>[1], then?: (user: User) => void | Promise<void>): void;

package/highlevel/methods/auth/send-code.d.cts

@@ -0,0 +1,18 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { SentCode } from '../../types/auth/sent-code.js';
+/**
+ * Send the confirmation code to the given phone number
+ *
+ * @returns  An object containing information about the sent confirmation code
+ */
+export declare function sendCode(client: ITelegramClient, params: {
+    /** Phone number in international format */
+    phone: string;
+    /** Saved future auth tokens, if any */
+    futureAuthTokens?: Uint8Array[];
+    /** Additional code settings to pass to the server */
+    codeSettings?: Omit<tl.RawCodeSettings, '_' | 'logoutTokens'>;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+}): Promise<SentCode>;

package/highlevel/methods/auth/send-recovery-code.d.cts

@@ -0,0 +1,7 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Send a code to email needed to recover your password
+ *
+ * @returns  String containing email pattern to which the recovery code was sent
+ */
+export declare function sendRecoveryCode(client: ITelegramClient): Promise<string>;

package/highlevel/methods/auth/sign-in-bot.d.cts

@@ -0,0 +1,10 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/peers/user.js';
+/**
+ * Authorize a bot using its token issued by [@BotFather](//t.me/BotFather)
+ *
+ * @param token  Bot token issued by BotFather
+ * @returns  Bot's {@link User} object
+ * @throws BadRequestError  In case the bot token is invalid
+ */
+export declare function signInBot(client: ITelegramClient, token: string): Promise<User>;

package/highlevel/methods/auth/sign-in-qr.d.cts

@@ -0,0 +1,33 @@
+import { MaybePromise } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { MaybeDynamic, User } from '../../types/index.js';
+/**
+ * Execute the [QR login flow](https://core.telegram.org/api/qr-login).
+ *
+ * This method will resolve once the authorization is complete,
+ * returning the authorized user.
+ */
+export declare function signInQr(client: ITelegramClient, params: {
+    /**
+     * Function that will be called whenever the login URL is changed.
+     *
+     * The app is expected to display `url` as a QR code to the user
+     */
+    onUrlUpdated: (url: string, expires: Date) => void;
+    /**
+     * Function that will be called when the user has scanned the QR code
+     * (i.e. when `updateLoginToken` is received), and the library is finalizing the auth
+     */
+    onQrScanned?: () => void;
+    /** Password for 2FA */
+    password?: MaybeDynamic<string>;
+    /**
+     * Function that will be called after the server has rejected the password.
+     *
+     * Note that in case {@link password} is not a function,
+     * this callback will never be called, and an error will be thrown instead.
+     */
+    invalidPasswordCallback?: () => MaybePromise<void>;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+}): Promise<User>;

package/highlevel/methods/auth/sign-in.d.cts

@@ -0,0 +1,19 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/peers/user.js';
+/**
+ * Authorize a user in Telegram with a valid confirmation code.
+ *
+ * @returns  If the code was valid and authorization succeeded, the {@link User} is returned.
+ * @throws  BadRequestError  In case the arguments are invalid
+ * @throws  SessionPasswordNeededError  In case a password is needed to sign in
+ */
+export declare function signIn(client: ITelegramClient, params: {
+    /** Phone number in international format */
+    phone: string;
+    /** Code identifier from {@link sendCode} */
+    phoneCodeHash: string;
+    /** The confirmation code that was received */
+    phoneCode: string;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+}): Promise<User>;

package/highlevel/methods/auth/start-test.d.cts

@@ -0,0 +1,30 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/index.js';
+/**
+ * Utility function to quickly authorize on test DC
+ * using a [Test phone number](https://core.telegram.org/api/auth#test-phone-numbers),
+ * which is randomly generated by default.
+ *
+ * > **Note**: Using this method assumes that you
+ * > are using a test DC in `primaryDc` parameter.
+ *
+ * @param params  Additional parameters
+ */
+export declare function startTest(client: ITelegramClient, params?: {
+    /**
+     * Whether to log out if current session is logged in.
+     *
+     * @default  false.
+     */
+    logout?: boolean;
+    /**
+     * Override phone number. Must be a valid Test phone number.
+     *
+     * By default is randomly generated.
+     */
+    phone?: string;
+    /**
+     * Override user's DC. Must be a valid test DC.
+     */
+    dcId?: number;
+}): Promise<User>;

package/highlevel/methods/auth/start.d.cts

@@ -0,0 +1,89 @@
+import { MaybePromise } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { SentCode } from '../../types/auth/sent-code.js';
+import { User } from '../../types/peers/user.js';
+import { MaybeDynamic } from '../../types/utils.js';
+import { InputStringSessionData } from '../../utils/string-session.js';
+import { tl } from '@mtcute/tl';
+/**
+ * Start the client in an interactive and declarative manner,
+ * by providing callbacks for authorization details.
+ *
+ * This method handles both login and sign up, and also handles 2FV
+ *
+ * All parameters are `MaybeDynamic<T>`, meaning you
+ * can either supply `T`, or a function that returns `MaybePromise<T>`
+ *
+ * This method is intended for simple and fast use in automated
+ * scripts and bots. If you are developing a custom client,
+ * you'll probably need to use other auth methods.
+ */
+export declare function start(client: ITelegramClient, params: {
+    /**
+     * String session exported using {@link TelegramClient.exportSession}.
+     *
+     * This simply calls {@link TelegramClient.importSession} before anything else.
+     *
+     * Note that passed session will be ignored in case storage already
+     * contains authorization.
+     */
+    session?: string | InputStringSessionData;
+    /**
+     * Whether to overwrite existing session.
+     */
+    sessionForce?: boolean;
+    /**
+     * When passed, [QR login flow](https://core.telegram.org/api/qr-login)
+     * will be used instead of the regular login flow.
+     *
+     * This function will be called whenever the login URL is changed,
+     * and the app is expected to display it as a QR code to the user.
+     */
+    qrCodeHandler?: (url: string, expires: Date) => void;
+    /**
+     * Phone number of the account.
+     * If account does not exist, it will be created
+     */
+    phone?: MaybeDynamic<string>;
+    /**
+     * Bot token to use. Ignored if `phone` is supplied.
+     */
+    botToken?: MaybeDynamic<string>;
+    /**
+     * 2FA password. Ignored if `botToken` is supplied
+     */
+    password?: MaybeDynamic<string>;
+    /**
+     * Code sent to the phone (either sms, call, flash call or other).
+     * Ignored if `botToken` is supplied, must be present if `phone` is supplied.
+     */
+    code?: MaybeDynamic<string>;
+    /**
+     * If passed, this function will be called if provided code or 2FA password
+     * was invalid. New code/password will be requested later.
+     *
+     * If provided `code`/`password` is a constant string, providing an
+     * invalid one will interrupt authorization flow.
+     */
+    invalidCodeCallback?: (type: 'code' | 'password') => MaybePromise<void>;
+    /**
+     * Whether to force code delivery through SMS
+     */
+    forceSms?: boolean;
+    /**
+     * Custom method that is called when a code is sent. Can be used
+     * to show a GUI alert of some kind.
+     *
+     * This method is called *before* {@link start.params.code}.
+     *
+     * @param code
+     * @default  `console.log`.
+     */
+    codeSentCallback?: (code: SentCode) => MaybePromise<void>;
+    /** Saved future auth tokens, if any */
+    futureAuthTokens?: Uint8Array[];
+    /** Additional code settings to pass to the server */
+    codeSettings?: Omit<tl.RawCodeSettings, '_' | 'logoutTokens'>;
+    /** Abort signal */
+    abortSignal?: AbortSignal;
+}): Promise<User>;

package/highlevel/methods/auth/utils.d.cts

@@ -0,0 +1,9 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/peers/user.js';
+/** @internal */
+export declare function _onAuthorization(client: ITelegramClient, auth: tl.auth.TypeAuthorization): Promise<User>;
+/**
+ * Check if the given peer/input peer is referring to the current user
+ */
+export declare function isSelfPeer(client: ITelegramClient, peer: tl.TypeInputPeer | tl.TypePeer | tl.TypeInputUser): boolean;

package/highlevel/methods/bots/answer-callback-query.d.cts

@@ -0,0 +1,41 @@
+import { ITelegramClient } from '../../client.types.js';
+import { CallbackQuery } from '../../types/updates/callback-query.js';
+import { default as Long } from 'long';
+/**
+ * Send an answer to a callback query.
+ *
+ * @param queryId  ID of the callback query, or the query itself
+ * @param params  Parameters of the answer
+ */
+export declare function answerCallbackQuery(client: ITelegramClient, queryId: Long | CallbackQuery, params?: {
+    /**
+     * Maximum amount of time in seconds for which
+     * this result can be cached by the client (not server!).
+     *
+     * @default  0
+     */
+    cacheTime?: number;
+    /**
+     * Text of the notification (0-200 chars).
+     *
+     * If not set, nothing will be displayed
+     */
+    text?: string;
+    /**
+     * Whether to show an alert in the middle of the screen
+     * instead of a notification at the top of the screen.
+     *
+     * @default  false
+     */
+    alert?: boolean;
+    /**
+     * URL that the client should open.
+     *
+     * If this was a button containing a game,
+     * you can provide arbitrary link to your game.
+     * Otherwise, you can only use links in the format
+     * `t.me/your_bot?start=...` that open your bot
+     * with a deep-link parameter.
+     */
+    url?: string;
+}): Promise<void>;

package/highlevel/methods/bots/answer-inline-query.d.cts

@@ -0,0 +1,88 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputInlineResult } from '../../types/bots/index.js';
+import { InlineQuery } from '../../types/updates/inline-query.js';
+/**
+ * Answer an inline query.
+ *
+ * @param queryId  Inline query ID
+ * @param results  Results of the query
+ * @param params  Additional parameters
+ */
+export declare function answerInlineQuery(client: ITelegramClient, queryId: tl.Long | InlineQuery, results: InputInlineResult[], params?: {
+    /**
+     * Maximum number of time in seconds that the results of the
+     * query may be cached on the server for.
+     *
+     * @default  300
+     */
+    cacheTime?: number;
+    /**
+     * Whether the results should be displayed as a gallery instead
+     * of a vertical list. Only applicable to some media types.
+     *
+     * In some cases changing this may lead to the results not being
+     * displayed by the client.
+     *
+     * Default is derived automatically based on result types
+     */
+    gallery?: boolean;
+    /**
+     * Whether the results should only be cached on the server
+     * for the user who sent the query.
+     *
+     * @default  false
+     */
+    private?: boolean;
+    /**
+     * Next pagination offset (up to 64 bytes).
+     *
+     * When user has reached the end of the current results,
+     * the client will re-send the inline query with the same text, but
+     * with `offset` set to this value.
+     *
+     * If omitted or empty string is provided, it is assumed that
+     * there are no more results.
+     */
+    nextOffset?: string;
+    /**
+     * If passed, clients will display a button before any other results,
+     * that when clicked switches the user to a private chat with the bot
+     * and sends the bot `/start ${parameter}`.
+     *
+     * An example from the Bot API docs:
+     *
+     * An inline bot that sends YouTube videos can ask the user to connect
+     * the bot to their YouTube account to adapt search results accordingly.
+     * To do this, it displays a "Connect your YouTube account" button above
+     * the results, or even before showing any. The user presses the button,
+     * switches to a private chat with the bot and, in doing so, passes a start
+     * parameter that instructs the bot to return an oauth link. Once done, the
+     * bot can offer a switch_inline button so that the user can easily return to
+     * the chat where they wanted to use the bot's inline capabilities
+     */
+    switchPm?: {
+        /**
+         * Text of the button
+         */
+        text: string;
+        /**
+         * Parameter for `/start` command
+         */
+        parameter: string;
+    };
+    /**
+     * If passed, clients will display a button on top of the remaining inline result
+     * list with the specified text, that switches the user to the specified bot web app.
+     */
+    switchWebview?: {
+        /**
+         * Text of the button
+         */
+        text: string;
+        /**
+         * URL to open
+         */
+        url: string;
+    };
+}): Promise<void>;

package/highlevel/methods/bots/answer-pre-checkout-query.d.cts

@@ -0,0 +1,12 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { PreCheckoutQuery } from '../../types/updates/pre-checkout-query.js';
+/**
+ * Answer a pre-checkout query.
+ *
+ * @param queryId  Pre-checkout query ID
+ */
+export declare function answerPreCheckoutQuery(client: ITelegramClient, queryId: tl.Long | PreCheckoutQuery, params?: {
+    /** If pre-checkout is rejected, error message to show to the user */
+    error?: string;
+}): Promise<void>;

package/highlevel/methods/bots/delete-my-commands.d.cts

@@ -0,0 +1,22 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { BotCommands } from '../../types/index.js';
+/**
+ * Delete commands for the current bot and the given scope.
+ *
+ * Does the same as passing `null` to  {@link setMyCommands}
+ *
+ * Learn more about scopes in the [Bot API docs](https://core.telegram.org/bots/api#botcommandscope)
+ */
+export declare function deleteMyCommands(client: ITelegramClient, params?: {
+    /**
+     * Scope of the commands.
+     *
+     * @default  `BotScope.default_` (i.e. `botCommandScopeDefault`)
+     */
+    scope?: tl.TypeBotCommandScope | BotCommands.IntermediateScope;
+    /**
+     * User language applied to the scope.
+     */
+    langCode?: string;
+}): Promise<void>;

package/highlevel/methods/bots/get-bot-info.d.cts

@@ -0,0 +1,18 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Gets information about a bot the current uzer owns (or the current bot)
+ */
+export declare function getBotInfo(client: ITelegramClient, params: {
+    /**
+     * When called by a user, a bot the user owns must be specified.
+     * When called by a bot, must be empty
+     */
+    bot?: InputPeerLike;
+    /**
+     * If passed, will retrieve the bot's description in the given language.
+     * If left empty, will retrieve the fallback description.
+     */
+    langCode?: string;
+}): Promise<tl.bots.RawBotInfo>;

package/highlevel/methods/bots/get-bot-menu-button.d.cts

@@ -0,0 +1,7 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Fetches the menu button set for the given user.
+ */
+export declare function getBotMenuButton(client: ITelegramClient, user: InputPeerLike): Promise<tl.TypeBotMenuButton>;

package/highlevel/methods/bots/get-callback-answer.d.cts

@@ -0,0 +1,41 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId } from '../../types/index.js';
+/**
+ * Request a callback answer from a bot,
+ * i.e. click an inline button that contains data.
+ *
+ * @param params
+ */
+export declare function getCallbackAnswer(client: ITelegramClient, params: InputMessageId & {
+    /** Data contained in the button */
+    data: string | Uint8Array;
+    /**
+     * Timeout for the query in ms.
+     *
+     * @default  `10000` (10 sec)
+     */
+    timeout?: number;
+    /**
+     * Whether to "fire and forget" this request,
+     * in which case the promise will resolve as soon
+     * as the request is sent with an empty response.
+     *
+     * Useful for interacting with bots that don't correctly
+     * answer to callback queries and the request always times out.
+     *
+     * **Note**: any errors will be silently ignored.
+     */
+    fireAndForget?: boolean;
+    /**
+     * Whether this is a "play game" button
+     */
+    game?: boolean;
+    /**
+     * If the button requires password entry, your 2FA password.
+     *
+     * Your password is never exposed to the bot,
+     * it is checked by Telegram.
+     */
+    password?: string;
+}): Promise<tl.messages.TypeBotCallbackAnswer>;