@mtcute/core 0.18.0-rc.5 → 0.18.0

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

@@ -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/bots/webview.d.cts

@@ -0,0 +1,114 @@
+import { tl } from '@mtcute/tl';
+import { InputPeerLike } from '../peers/peer.js';
+/**
+ * Information about the mini app for {@link openWebview} method
+ *
+ * - `main` - the ["main"](https://corefork.telegram.org/api/bots/webapps#main-mini-apps) mini-app, configured via BotFather
+ * - `from_reply_keyboard` - webview button found in [reply keyboards](https://corefork.telegram.org/api/bots/webapps#keyboard-button-mini-apps)
+ * - `from_switch_inline` - webview button found [at the top of inline results](https://corefork.telegram.org/api/bots/webapps#inline-mode-mini-apps)
+ * - `from_side_menu` - webview button found in the [side menu](https://corefork.telegram.org/api/bots/webapps#side-menu-mini-apps)
+ * - `from_inline_keyboard` - webview button found in [inline keyboards](https://corefork.telegram.org/api/bots/webapps#inline-button-mini-apps)
+ * - `from_bot_menu` - webview button found in [bot menus](https://corefork.telegram.org/api/bots/webapps#menu-button-mini-apps)
+ * - `from_attach_menu` - webview button found in [attachment menus](https://corefork.telegram.org/api/bots/webapps#attachment-menu-mini-apps)
+ * - `from_link` - webview opened via [direct links](https://corefork.telegram.org/api/bots/webapps#direct-link-mini-apps)
+ */
+export type InputWebview = {
+    type: 'main';
+    /**
+     * If set, requests to open the mini app in compact mode (as opposed to fullview mode).
+     * Must be set if the `mode` parameter of the Main Mini App link is equal to `compact`.
+     */
+    compact?: boolean;
+    /** Start parameter from the deep link for the mini app */
+    startParam?: string;
+} | {
+    type: 'from_reply_keyboard' | 'from_switch_inline';
+    /** URL of the mini app found in the button */
+    url: string;
+} | {
+    type: 'from_side_menu';
+} | {
+    type: 'from_inline_keyboard' | 'from_bot_menu';
+    /** URL of the mini app found in the button */
+    url: string;
+    /**
+     * If set, requests to open the mini app in compact mode (as opposed to fullview mode).
+     * Must be set if the `mode` parameter of the Main Mini App link is equal to `compact`.
+     */
+    compact?: boolean;
+    /** ID of the message to which we should reply if the mini app asks to do so */
+    replyTo?: number | tl.TypeInputReplyTo;
+    /**
+     * Peer to use when sending the message.
+     */
+    sendAs?: InputPeerLike;
+    /** If the mini app asks to send a message, whether to send it silently */
+    silent?: boolean;
+    /**
+     * Telegram asks us to keep sending `messages.prolongWebView` requests every minute until the webview is closed.
+     * If this parameter is set to `true`, the timer will not be started, and the webview will never be prolonged.
+     */
+    fireAndForget?: boolean;
+} | {
+    type: 'from_attach_menu';
+    /**
+     * If set, requests to open the mini app in compact mode (as opposed to fullview mode).
+     * Must be set if the `mode` parameter of the Main Mini App link is equal to `compact`.
+     */
+    compact?: boolean;
+    /** ID of the message to which we should reply if the mini app asks to do so */
+    replyTo?: number | tl.TypeInputReplyTo;
+    /**
+     * Peer to use when sending the message.
+     */
+    sendAs?: InputPeerLike;
+    /** If the mini app asks to send a message, whether to send it silently */
+    silent?: boolean;
+    /**
+     * Telegram asks us to keep sending `messages.prolongWebView` requests every minute until the webview is closed.
+     * If this parameter is set to `true`, the timer will not be started, and the webview will never be prolonged.
+     */
+    fireAndForget?: boolean;
+} | {
+    type: 'from_link';
+    /** Short name of the app (from the link) */
+    shortName: string;
+    /**
+     * If the bot is asking permission to send messages to the user,
+     * whether to allow it to do so
+     */
+    allowWrite?: boolean;
+    /**
+     * If set, requests to open the mini app in compact mode (as opposed to fullview mode).
+     * Must be set if the `mode` parameter of the Main Mini App link is equal to `compact`.
+     */
+    compact?: boolean;
+    /** Start parameter from the deep link for the mini app */
+    startParam?: string;
+    /**
+     * Telegram asks us to keep sending `messages.prolongWebView` requests every minute until the webview is closed.
+     * If this parameter is set to `true`, the timer will not be started, and the webview will never be prolonged.
+     */
+    fireAndForget?: boolean;
+};
+/**
+ * Result of {@link openWebview} method call
+ */
+export declare class WebviewResult {
+    readonly raw: tl.RawWebViewResultUrl;
+    /** If true, the caller should use `closeWebview` method eventually to close the webview */
+    readonly shouldBeClosed: boolean;
+    constructor(raw: tl.RawWebViewResultUrl, 
+    /** If true, the caller should use `closeWebview` method eventually to close the webview */
+    shouldBeClosed?: boolean);
+    /** Whether the webview should be opened as a landscape fullscreen app */
+    get isFullscreen(): boolean;
+    /** Whether the webview should be opened in "compact" mode */
+    get isCompact(): boolean;
+    /**
+     * Webview session ID (only returned by inline button mini apps, menu button mini apps, attachment menu mini apps).
+     */
+    get queryId(): tl.Long | null;
+    /** Actual URL to open */
+    get url(): string;
+}

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

@@ -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/calls/index.d.cts

@@ -0,0 +1 @@
+export * from './discard-reason.js';

package/highlevel/types/conversation.d.cts

@@ -0,0 +1,210 @@
+import { tl } from '@mtcute/tl';
+import { MaybePromise } from '../../types/utils.js';
+import { ITelegramClient } from '../client.types.js';
+import { Message } from './messages/message.js';
+import { InputPeerLike } from './peers/index.js';
+import { ParsedUpdate } from './updates/index.js';
+import { ParametersSkip2 } from './utils.js';
+import { sendMediaGroup } from '../methods/messages/send-media-group.js';
+import { sendMedia } from '../methods/messages/send-media.js';
+import { sendText } from '../methods/messages/send-text.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.cts

@@ -0,0 +1,33 @@
+import { InputPeerLike } from './peers/index.js';
+import { MtcuteError } from '../../types/errors.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.cts

@@ -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/index.d.cts

@@ -0,0 +1,4 @@
+export * from './file-location.js';
+export * from './uploaded-file.js';
+export * from './utils.js';
+export * from './web-document.js';

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

@@ -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.cts

@@ -0,0 +1,89 @@
+import { IReadable } from '@fuman/io';
+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 | IReadable | 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.cts

@@ -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;
+}

package/highlevel/types/index.d.cts

@@ -0,0 +1,15 @@
+export * from './auth/index.js';
+export * from './bots/index.js';
+export * from './calls/index.js';
+export * from './conversation.js';
+export * from './errors.js';
+export * from './files/index.js';
+export * from './media/index.js';
+export * from './messages/index.js';
+export * from './misc/index.js';
+export * from './peers/index.js';
+export * from './premium/index.js';
+export * from './reactions/index.js';
+export * from './stories/index.js';
+export * from './updates/index.js';
+export * from './utils.js';

package/highlevel/types/media/audio.d.cts

@@ -0,0 +1,31 @@
+import { tl } from '@mtcute/tl';
+import { tdFileId } from '@mtcute/file-id';
+import { RawDocument } from './document.js';
+/**
+ * An audio file
+ */
+export declare class Audio extends RawDocument {
+    /** TL object describing the audio */
+    readonly attr: tl.RawDocumentAttributeAudio;
+    /** Type of the media (for use in a tagged union) */
+    readonly type: "audio";
+    /** Type of the file for File ID generation */
+    protected _fileIdType(): tdFileId.FileType;
+    constructor(doc: tl.RawDocument, 
+    /** TL object describing the audio */
+    attr: tl.RawDocumentAttributeAudio);
+    /**
+     * Duration of the audio in seconds.
+     *
+     * May not be accurate since provided by the sender.
+     */
+    get duration(): number;
+    /**
+     * Performer of the audio track.
+     */
+    get performer(): string | null;
+    /**
+     * Title of the audio track.
+     */
+    get title(): string | null;
+}