@mtcute/core 0.16.7 → 0.16.9

package/highlevel/types/bots/keyboards/factories.d.ts

@@ -0,0 +1,201 @@
+import { tl } from '@mtcute/tl';
+import { BotKeyboardBuilder } from './builder.js';
+import { InlineKeyboardMarkup, ReplyKeyboardForceReply, ReplyKeyboardHide, ReplyKeyboardMarkup, ReplyMarkup } from './types.js';
+/** Create a keyboard builder */
+export declare function builder(maxRowWidth?: number | null): BotKeyboardBuilder;
+/**
+ * Create an inline keyboard markup
+ *
+ * @param buttons  Two-dimensional array of buttons
+ */
+export declare function inline(buttons: tl.TypeKeyboardButton[][]): InlineKeyboardMarkup;
+/**
+ * Create a reply keyboard markup
+ *
+ * @param buttons  Two-dimensional array of buttons
+ * @param params  Additional parameters for the keyboard
+ */
+export declare function reply(buttons: tl.TypeKeyboardButton[][], params?: Omit<ReplyKeyboardMarkup, 'type' | 'buttons'>): ReplyKeyboardMarkup;
+/**
+ * Hide the previously sent reply keyboard
+ *
+ * @param selective
+ *     Whether to remove the keyboard for specific users only. Targets:
+ *      - users that are @mentioned in the text of the Message
+ *      - in case this is a reply, sender of the original message
+ */
+export declare function hideReply(selective?: boolean): ReplyKeyboardHide;
+/**
+ * Force the user to send a reply
+ */
+export declare function forceReply(params?: Omit<ReplyKeyboardForceReply, 'type'>): ReplyKeyboardForceReply;
+/**
+ * Create a text-only keyboard button.
+ *
+ * Used for reply keyboards, not inline!
+ *
+ * @param text  Button text
+ */
+export declare function text(text: string): tl.RawKeyboardButton;
+/**
+ * Create a keyboard button requesting for user's contact.
+ * Available only for private chats.
+ *
+ * Used for reply keyboards, not inline!
+ *
+ * @param text  Button text
+ */
+export declare function requestContact(text: string): tl.RawKeyboardButtonRequestPhone;
+/**
+ * Create a keyboard button requesting for user's geo location.
+ * Available only for private chats.
+ *
+ * Used for reply keyboards, not inline!
+ *
+ * @param text  Button text
+ */
+export declare function requestGeo(text: string): tl.RawKeyboardButtonRequestGeoLocation;
+/**
+ * Create a keyboard button requesting the user to create and send a poll.
+ * Available only for private chats.
+ *
+ * Used for reply keyboards, not inline!
+ *
+ * @param text  Button text
+ * @param quiz  If set, only quiz polls can be sent
+ */
+export declare function requestPoll(text: string, quiz?: boolean): tl.RawKeyboardButtonRequestPoll;
+/**
+ * Create a keyboard button with a link.
+ *
+ * Used for inline keyboards, not reply!
+ *
+ * @param text  Button text
+ * @param url  URL
+ */
+export declare function url(text: string, url: string): tl.RawKeyboardButtonUrl;
+/**
+ * Create a keyboard button with a link.
+ *
+ * Used for inline keyboards, not reply!
+ *
+ * @param text  Button text
+ * @param data  Callback data (1-64 bytes). String will be converted to `Buffer`
+ * @param requiresPassword
+ *   Whether the user should verify their identity by entering 2FA password.
+ *   See more: {@link tl.RawKeyboardButtonCallback#requiresPassword}
+ */
+export declare function callback(text: string, data: string | Uint8Array, requiresPassword?: boolean): tl.RawKeyboardButtonCallback;
+/**
+ * Button to force a user to switch to inline mode.
+ *
+ * Pressing the button will prompt the user to select
+ * one of their chats, open that chat and insert the bot‘s
+ * username and the specified inline query (if any) in the input field.
+ *
+ * Used for inline keyboards, not reply!
+ *
+ * @param text  Button text
+ * @param query  Inline query (can be empty or omitted)
+ * @param currentChat
+ *     If set, pressing the button will insert the bot's username
+ *     and the specified inline query in the current chat's input field
+ */
+export declare function switchInline(text: string, query?: string, currentChat?: boolean): tl.RawKeyboardButtonSwitchInline;
+/**
+ * Button to start a game
+ *
+ * Used for inline keyboards, not reply!
+ *
+ * **Note**: This type of button must always be
+ * the first button in the first row. ID of the
+ * game is inferred from {@link InputMedia.game},
+ * thus this button should only be used with it.
+ */
+export declare function game(text: string): tl.RawKeyboardButtonGame;
+/**
+ * Button to pay for a product.
+ *
+ * Used for inline keyboards, not reply!
+ *
+ * **Note**: This type of button must always be
+ * the first button in the first row. Related
+ * invoice is inferred from {@link InputMedia.invoice},
+ * thus this button should only be used with it.
+ */
+export declare function pay(text: string): tl.RawKeyboardButtonBuy;
+/**
+ * Button to authorize a user
+ *
+ * Used for inline keyboards, not reply!
+ *
+ * @param text  Button label
+ * @param url  Authorization URL (see {@link tl.RawInputKeyboardButtonUrlAuth})
+ * @param params
+ */
+export declare function urlAuth(text: string, url: string, params?: {
+    /**
+     * Button label when forwarded
+     */
+    fwdText?: string;
+    /**
+     * Whether to request the permission for
+     * your bot to send messages to the user
+     */
+    requestWriteAccess?: boolean;
+    /**
+     * Bot, which will be used for user authorization.
+     * `url` domain must be the same as the domain linked
+     * with the bot.
+     *
+     * @default  current bot
+     */
+    bot?: tl.TypeInputUser;
+}): tl.RawInputKeyboardButtonUrlAuth;
+/**
+ * Button to open webview
+ *
+ * Used for both inline keyboards and reply ones
+ *
+ * @param text  Button label
+ * @param url  WebView URL
+ */
+export declare function webView(text: string, url: string): tl.RawKeyboardButtonWebView;
+/**
+ * Button to open user profile
+ *
+ * @param text  Text of the button
+ * @param user  User to be opened (use {@link TelegramClient.resolvePeer})
+ */
+export declare function userProfile(text: string, user: tl.TypeInputPeer): tl.RawInputKeyboardButtonUserProfile;
+/**
+ * Button to request a peer from the user
+ *
+ * @param text  Text of the button
+ * @param buttonId  ID of the button that will later be passed to the service message
+ */
+export declare function requestPeer(text: string, buttonId: number, params: {
+    /**
+     * Peer type, along with filters
+     */
+    peerType: tl.TypeRequestPeerType;
+    /**
+     * Maximum number of peers to be selected
+     *
+     * @default  1
+     */
+    count?: number;
+}): tl.RawKeyboardButtonRequestPeer;
+/**
+ * Find a button in the keyboard by its text or by predicate
+ *
+ * @param buttons  Two-dimensional array of buttons
+ * @param predicate  Button text or predicate function
+ */
+export declare function findButton(buttons: tl.TypeKeyboardButton[][], predicate: string | ((btn: tl.TypeKeyboardButton) => boolean)): tl.TypeKeyboardButton | null;
+/** @internal */
+export declare function _rowsTo2d(rows: tl.RawKeyboardButtonRow[]): tl.TypeKeyboardButton[][];
+/** @internal */
+export declare function _2dToRows(arr: tl.TypeKeyboardButton[][], inline: boolean): tl.RawKeyboardButtonRow[];
+/** @internal */
+export declare function _convertToTl(obj?: ReplyMarkup): tl.TypeReplyMarkup | undefined;

package/highlevel/types/bots/keyboards/keyboards.test.d.ts

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

package/highlevel/types/bots/keyboards/types.d.ts

@@ -0,0 +1,34 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Reply keyboard markup
+ */
+export interface ReplyKeyboardMarkup extends Omit<tl.RawReplyKeyboardMarkup, '_' | 'rows'> {
+    readonly type: 'reply';
+    /**
+     * Two-dimensional array of buttons
+     */
+    readonly buttons: tl.TypeKeyboardButton[][];
+}
+/**
+ * Hide previously sent bot keyboard
+ */
+export interface ReplyKeyboardHide extends Omit<tl.RawReplyKeyboardHide, '_'> {
+    readonly type: 'reply_hide';
+}
+/**
+ * Force the user to send a reply
+ */
+export interface ReplyKeyboardForceReply extends Omit<tl.RawReplyKeyboardForceReply, '_'> {
+    readonly type: 'force_reply';
+}
+/**
+ * Inline keyboard markup
+ */
+export interface InlineKeyboardMarkup {
+    readonly type: 'inline';
+    /**
+     * Two-dimensional array of buttons
+     */
+    readonly buttons: tl.TypeKeyboardButton[][];
+}
+export type ReplyMarkup = ReplyKeyboardMarkup | ReplyKeyboardHide | ReplyKeyboardForceReply | InlineKeyboardMarkup | tl.TypeReplyMarkup;

package/highlevel/types/calls/discard-reason.d.ts

@@ -0,0 +1,13 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Phone call discard reason. Can be:
+ *  - `missed`: The call was missed
+ *  - `disconnect`: The connection has interrupted
+ *  - `hangup`: The call was ended normally
+ *  - `busy`: The call was discarded because the user is in another call
+ */
+export type CallDiscardReason = 'missed' | 'disconnect' | 'hangup' | 'busy';
+/** @internal */
+export declare function _callDiscardReasonFromTl(raw: tl.TypePhoneCallDiscardReason): CallDiscardReason;
+/** @internal */
+export declare function _callDiscardReasonToTl(r: CallDiscardReason): tl.TypePhoneCallDiscardReason;

package/highlevel/types/conversation.d.ts

@@ -0,0 +1,210 @@
+import { tl } from '@mtcute/tl';
+import { MaybePromise } from '../../types/utils.js';
+import { ITelegramClient } from '../client.types.js';
+import { sendMedia } from '../methods/messages/send-media.js';
+import { sendMediaGroup } from '../methods/messages/send-media-group.js';
+import { sendText } from '../methods/messages/send-text.js';
+import { Message } from './messages/message.js';
+import { InputPeerLike } from './peers/index.js';
+import { ParsedUpdate } from './updates/index.js';
+import { ParametersSkip2 } from './utils.js';
+/**
+ * Represents a conversation inside some chat.
+ *
+ * A conversation keeps track of any messages sent or edited
+ * since it was started and until it was stopped,
+ * and allows waiting for events in it.
+ *
+ * If you need a conversation across multiple chats,
+ * you should use multiple {@link Conversation} objects
+ * and synchronize them manually.
+ */
+export declare class Conversation {
+    readonly client: ITelegramClient;
+    readonly chat: InputPeerLike;
+    private _inputPeer;
+    private _chatId;
+    private _started;
+    private _lastMessage;
+    private _lastReceivedMessage;
+    private _queuedNewMessage;
+    private _pendingNewMessages;
+    private _lock;
+    private _pendingEditMessage;
+    private _recentEdits;
+    private _pendingRead;
+    constructor(client: ITelegramClient, chat: InputPeerLike);
+    private static _getState;
+    /**
+     * Pass the update to the conversation manager and all registered
+     * conversations on this client.
+     *
+     * @returns `true` if the update was handled by some conversation
+     */
+    static handleUpdate(client: ITelegramClient, update: ParsedUpdate): boolean;
+    /**
+     * Get the input peer that this conversation is with
+     */
+    get inputPeer(): tl.TypeInputPeer;
+    /**
+     * ID of the very last message in this conversation.
+     */
+    get lastMessage(): number;
+    /**
+     * ID of the last incoming message in this conversation.
+     *
+     * Note that before any messages were received since the {@link start}
+     * of the conversation, this will equal to {@link lastMessage}
+     */
+    get lastReceivedMessage(): number;
+    /**
+     * Start the conversation
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the conversation
+     */
+    stop(): void;
+    private _recordMessage;
+    /**
+     * Send a text message to this conversation.
+     *
+     * Wrapper over {@link sendText}
+     */
+    sendText(...params: ParametersSkip2<typeof sendText>): ReturnType<typeof sendText>;
+    /**
+     * Send a media to this conversation.
+     *
+     * Wrapper over {@link sendMedia}
+     */
+    sendMedia(...params: ParametersSkip2<typeof sendMedia>): ReturnType<typeof sendMedia>;
+    /**
+     * Send a media group to this conversation.
+     *
+     * Wrapper over {@link sendMediaGroup}
+     */
+    sendMediaGroup(...params: ParametersSkip2<typeof sendMediaGroup>): ReturnType<typeof sendMediaGroup>;
+    /**
+     * Mark the conversation as read up to a certain point.
+     *
+     * By default, reads until the last message.
+     * You can pass `message=null` to read the entire conversation,
+     * or pass message ID to read up until that ID.
+     */
+    markRead({ message, clearMentions, }?: {
+        message?: number | null;
+        clearMentions?: boolean;
+    }): Promise<void>;
+    /**
+     * Helper method that calls {@link start},
+     * the provided function and then {@link stop}.
+     *
+     * It is preferred that you use this function rather than
+     * manually starting and stopping the conversation.
+     *
+     * If you don't stop the conversation when you're done,
+     * it *will* lead to memory leaks.
+     *
+     * @param handler
+     */
+    with<T>(handler: () => MaybePromise<T>): Promise<T>;
+    /**
+     * Wait for a new message in the conversation
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param [timeout]  Timeout for the handler in ms. Pass `null` to disable.
+     *   When the timeout is reached, `MtTimeoutError` is thrown.
+     */
+    waitForNewMessage(filter?: (msg: Message) => MaybePromise<boolean>, timeout?: number | null): Promise<Message>;
+    /**
+     * Wait for a response for the given message
+     * (def. the last one) in the conversation.
+     *
+     * A message is considered to be a response if
+     * it was sent after the given one.
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param params
+     */
+    waitForResponse(filter?: (msg: Message) => MaybePromise<boolean>, params?: {
+        /**
+         * Message for which to wait for response for.
+         *
+         * @default  last sent/received message
+         */
+        message?: number;
+        /**
+         * Timeout for the handler in ms. Pass `null` to disable.
+         *
+         * When the timeout is reached, `TimeoutError` is thrown.
+         *
+         * @default  `15000` (15 sec)
+         */
+        timeout?: number | null;
+    }): Promise<Message>;
+    /**
+     * Wait for the reply for the given message'
+     * (def. the last one) in the conversation.
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param params
+     */
+    waitForReply(filter?: (msg: Message) => MaybePromise<boolean>, params?: {
+        /**
+         * Message for which to wait for reply for.
+         *
+         * @default  last sent/received message
+         */
+        message?: number;
+        /**
+         * Timeout for the handler in ms. Pass `null` to disable.
+         *
+         * When the timeout is reached, `TimeoutError` is thrown.
+         *
+         * @default  `15000` (15 sec)
+         */
+        timeout?: number | null;
+    }): Promise<Message>;
+    /**
+     * Wait for a message to be edited in the conversation.
+     * By defaults wait for the last message sent by the other party
+     * (at the moment) to be edited.
+     *
+     * Returns the edited message.
+     *
+     * @param filter  Filter for the handler. You can use any filter you can use for dispatcher
+     * @param params
+     */
+    waitForEdit(filter?: (msg: Message) => MaybePromise<boolean>, params?: {
+        /**
+         * Message for which to wait for reply for.
+         *
+         * @default  last received message
+         */
+        message?: number;
+        /**
+         * Timeout for the handler in ms. Pass `null` to disable.
+         *
+         * When the timeout is reached, `TimeoutError` is thrown.
+         *
+         * @default  `15000` (15 sec)
+         */
+        timeout?: number | null;
+    }): Promise<Message>;
+    /**
+     * Wait for the message to be read by the other party.
+     *
+     * Note that reading the message doesn't mean the response was sent,
+     * and if the response was sent, it doesn't mean that the message was read.
+     *
+     * @param message  Message for which to wait for read for. Defaults to last message.
+     * @param timeout  Timeout for the handler in ms, def. 15 sec. Pass `null` to disable.
+     *   When the timeout is reached, `TimeoutError` is thrown.
+     */
+    waitForRead(message?: number, timeout?: number | null): Promise<void>;
+    private _onNewMessage;
+    private _onEditMessage;
+    private _onHistoryRead;
+    private _processPendingNewMessages;
+    private _processRecentEdits;
+}

package/highlevel/types/errors.d.ts

@@ -0,0 +1,33 @@
+import { MtcuteError } from '../../types/errors.js';
+import { InputPeerLike } from './peers/index.js';
+/**
+ * Could not find a peer by the provided information
+ */
+export declare class MtPeerNotFoundError extends MtcuteError {
+}
+/**
+ * Could not find a message by the provided information
+ */
+export declare class MtMessageNotFoundError extends MtcuteError {
+    readonly peerId: number;
+    readonly messageId: number;
+    readonly context?: string | undefined;
+    constructor(peerId: number, messageId: number, context?: string | undefined);
+}
+/**
+ * Some method that requires a particular type of peer
+ * is called, but the resolved peer type is invalid.
+ *
+ * For example, when trying to get common chats
+ * while providing another chat as `userId`
+ */
+export declare class MtInvalidPeerTypeError extends MtcuteError {
+    constructor(peer: InputPeerLike, expected: string);
+}
+/**
+ * Trying to access to some property on an object that does not
+ * contain that information.
+ */
+export declare class MtEmptyError extends MtcuteError {
+    constructor();
+}

package/highlevel/types/files/file-location.d.ts

@@ -0,0 +1,48 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Information about file location.
+ *
+ * Catch-all class for all kinds of Telegram file locations,
+ * including ones that are embedded directly into the entity.
+ */
+export declare class FileLocation {
+    /**
+     * Location of the file.
+     *
+     * Either a TL object declaring remote file location,
+     * a Buffer containing actual file content (for stripped thumbnails and vector previews),
+     * or a function that will return either of those.
+     *
+     * When a function is passed, it will be lazily resolved the
+     * first time downloading the file.
+     */
+    readonly location: tl.TypeInputFileLocation | tl.TypeInputWebFileLocation | Uint8Array | (() => tl.TypeInputFileLocation | tl.TypeInputWebFileLocation | Uint8Array);
+    /**
+     * File size in bytes, when available
+     */
+    readonly fileSize?: number | undefined;
+    /**
+     * DC ID of the file, when available
+     */
+    readonly dcId?: number | undefined;
+    constructor(
+    /**
+     * Location of the file.
+     *
+     * Either a TL object declaring remote file location,
+     * a Buffer containing actual file content (for stripped thumbnails and vector previews),
+     * or a function that will return either of those.
+     *
+     * When a function is passed, it will be lazily resolved the
+     * first time downloading the file.
+     */
+    location: tl.TypeInputFileLocation | tl.TypeInputWebFileLocation | Uint8Array | (() => tl.TypeInputFileLocation | tl.TypeInputWebFileLocation | Uint8Array), 
+    /**
+     * File size in bytes, when available
+     */
+    fileSize?: number | undefined, 
+    /**
+     * DC ID of the file, when available
+     */
+    dcId?: number | undefined);
+}

package/highlevel/types/files/uploaded-file.d.ts

@@ -0,0 +1,24 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Describes a file uploaded to the Telegram servers
+ * using {@link TelegramClient.uploadFile} method.
+ */
+export interface UploadedFile {
+    /**
+     * Raw TL input file to be used in other methods.
+     *
+     * Very low-level stuff, usually you shouldn't care about it.
+     */
+    inputFile: tl.TypeInputFile;
+    /**
+     * File size in bytes
+     */
+    size: number;
+    /**
+     * File MIME type, either the one passed or
+     * the one derived from file contents.
+     */
+    mime: string;
+}
+/** @internal */
+export declare function isUploadedFile(obj: unknown): obj is UploadedFile;

package/highlevel/types/files/utils.d.ts

@@ -0,0 +1,88 @@
+import { tdFileId } from '@mtcute/file-id';
+import { tl } from '@mtcute/tl';
+import { AnyToNever } from '../../../types/utils.js';
+import { FileLocation } from './file-location.js';
+import { UploadedFile } from './uploaded-file.js';
+/**
+ * Describes types that can be used in {@link TelegramClient.uploadFile}
+ * method. Can be one of:
+ *  - `Uint8Array`/`Buffer`, which will be interpreted as raw file contents
+ *  - `File`, `Blob` (from the Web API)
+ *  - `string`, which will be interpreted as file path (**non-browser only!**)
+ *  - `URL` (from the Web API, will be `fetch()`-ed; `file://` URLs are not available in browsers)
+ *  - `ReadStream` (for Node.js/Bun, from the `node:fs` module)
+ *  - `BunFile` (from `Bun.file()`)
+ *  - `Deno.FsFile` (from `Deno.open()` in Deno)
+ *  - `ReadableStream` (Web API readable stream)
+ *  - `Readable` (Node.js/Bun readable stream)
+ *  - `Response` (from `window.fetch`)
+ */
+export type UploadFileLike = URL | Uint8Array | File | Blob | string | AnyToNever<import('node:fs').ReadStream> | AnyToNever<ReadableStream<Uint8Array>> | AnyToNever<NodeJS.ReadableStream> | AnyToNever<Response> | AnyToNever<Deno.FsFile>;
+/**
+ * Describes types that can be used as an input
+ * to any methods that send media (like {@link TelegramClient.sendPhoto})
+ *
+ * Can be one of:
+ *  - `Buffer`, which will be interpreted as raw file contents
+ *  - `File` (from the Web API)
+ *  - `ReadStream` (for Node.js/Bun, from the `fs` module)
+ *  - `ReadableStream` (from the Web API, base readable stream)
+ *  - `Readable` (for Node.js/Bun, base readable stream)
+ *  - `BunFile` (from `Bun.file()`)
+ *  - `Deno.FsFile` (from `Deno.open()` in Deno)
+ *  - {@link UploadedFile} returned from {@link TelegramClient.uploadFile}
+ *  - `tl.TypeInputFile` and `tl.TypeInputMedia` TL objects
+ *  - `string` with a path to a local file prepended with `file:` (non-browser only) (e.g. `file:image.jpg`)
+ *  - `string` with a URL to remote files (e.g. `https://example.com/image.jpg`)
+ *  - `string` with TDLib and Bot API compatible File ID.
+ *  - `URL` (from the Web API, will be `fetch()`-ed if needed; `file://` URLs are not available in browsers)
+ *  - `td.RawFullRemoteFileLocation` (parsed File ID)
+ */
+export type InputFileLike = UploadFileLike | UploadedFile | tl.TypeInputFile | tl.TypeInputMedia | tdFileId.RawFullRemoteFileLocation;
+/**
+ * File location which should be downloaded.
+ * You can also provide TDLib and Bot API compatible File ID
+ */
+export type FileDownloadLocation = tl.TypeInputFileLocation | tl.TypeInputWebFileLocation | FileLocation | string;
+export interface FileDownloadParameters {
+    /**
+     * Total file size, if known.
+     * Used to determine upload part size.
+     * In some cases can be inferred from `file` automatically.
+     */
+    fileSize?: number;
+    /**
+     * Download part size (in KB).
+     * By default, automatically selected depending on the file size
+     * (or 64, if not provided). Must not be bigger than 512,
+     * must not be a fraction, and must be divisible by 4.
+     */
+    partSize?: number;
+    /**
+     * DC id from which the file will be downloaded.
+     *
+     * If provided DC is not the one storing the file,
+     * redirection will be handled automatically.
+     */
+    dcId?: number;
+    /**
+     * Offset in bytes. Must be divisible by 4096 (4 KB).
+     */
+    offset?: number;
+    /**
+     * Number of bytes to be downloaded.
+     * By default, downloads the entire file
+     */
+    limit?: number;
+    /**
+     * Function that will be called after some part has been downloaded.
+     *
+     * @param uploaded  Number of bytes already downloaded
+     * @param total  Total file size (`Infinity` if not available)
+     */
+    progressCallback?: (downloaded: number, total: number) => void;
+    /**
+     * Abort signal that can be used to cancel the download.
+     */
+    abortSignal?: AbortSignal;
+}

package/highlevel/types/files/web-document.d.ts

@@ -0,0 +1,32 @@
+import { tl } from '@mtcute/tl';
+import { FileLocation } from './file-location.js';
+/**
+ * An external web document, that is not
+ * stored on Telegram severs, and is available
+ * by a HTTP(s) url.
+ *
+ * > **Note**: not all web documents are downloadable
+ * > through Telegram. Media files usually are,
+ * > and web pages (i.e. `mimeType = text/html`) usually aren't.
+ * > To be sure, check `isDownloadable` property.
+ */
+export declare class WebDocument extends FileLocation {
+    readonly raw: tl.TypeWebDocument;
+    constructor(raw: tl.TypeWebDocument);
+    /**
+     * URL to the file
+     */
+    get url(): string;
+    /**
+     * MIME type of the file
+     */
+    get mimeType(): string;
+    /**
+     * Whether this file can be downloaded through Telegram.
+     *
+     * If `false`, you should use {@link url} to manually
+     * fetch data via HTTP(s), and trying to use `download*` methods
+     * will result in an error
+     */
+    get isDownloadable(): boolean;
+}