@mtcute/core 0.16.7 → 0.16.9

package/highlevel/methods/users/get-my-username.d.ts

@@ -0,0 +1,8 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Get currently authorized user's username.
+ *
+ * This method uses locally available information and
+ * does not call any API methods.
+ */
+export declare function getMyUsername(client: ITelegramClient): Promise<string | null>;

package/highlevel/methods/users/get-profile-photo.d.ts

@@ -0,0 +1,11 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Photo } from '../../types/index.js';
+/**
+ * Get a single profile picture of a user by its ID
+ *
+ * @param userId  User ID, username, phone number, `"me"` or `"self"`
+ * @param photoId  ID of the photo to fetch
+ * @param params
+ */
+export declare function getProfilePhoto(client: ITelegramClient, userId: InputPeerLike, photoId: tl.Long): Promise<Photo>;

package/highlevel/methods/users/get-profile-photos.d.ts

@@ -0,0 +1,22 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ArrayPaginated, InputPeerLike, Photo } from '../../types/index.js';
+/**
+ * Get a list of profile pictures of a user
+ *
+ * @param userId  User ID, username, phone number, `"me"` or `"self"`
+ * @param params
+ */
+export declare function getProfilePhotos(client: ITelegramClient, userId: InputPeerLike, params?: {
+    /**
+     * Offset from which to fetch.
+     *
+     * @default  `0`
+     */
+    offset?: number;
+    /**
+     * Maximum number of items to fetch (up to 100)
+     *
+     * @default  `100`
+     */
+    limit?: number;
+}): Promise<ArrayPaginated<Photo, number>>;

package/highlevel/methods/users/get-users.d.ts

@@ -0,0 +1,12 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, User } from '../../types/index.js';
+/**
+ * Get information about multiple users.
+ * You can retrieve up to 200 users at once.
+ *
+ * Note that order is not guaranteed.
+ *
+ * @param ids  Users' identifiers. Can be ID, username, phone number, `"me"`, `"self"` or TL object
+ */
+export declare function getUsers(client: ITelegramClient, ids: MaybeArray<InputPeerLike>): Promise<(User | null)[]>;

package/highlevel/methods/users/iter-profile-photos.d.ts

@@ -0,0 +1,23 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Photo } from '../../types/index.js';
+import { getProfilePhotos } from './get-profile-photos.js';
+/**
+ * Iterate over profile photos
+ *
+ * @param userId  User ID, username, phone number, `"me"` or `"self"`
+ * @param params
+ */
+export declare function iterProfilePhotos(client: ITelegramClient, userId: InputPeerLike, params?: Parameters<typeof getProfilePhotos>[2] & {
+    /**
+     * Maximum number of items to fetch
+     *
+     * @default  `Infinity`, i.e. all items are fetched
+     */
+    limit?: number;
+    /**
+     * Size of chunks which are fetched. Usually not needed.
+     *
+     * @default  100
+     */
+    chunkSize?: number;
+}): AsyncIterableIterator<Photo>;

package/highlevel/methods/users/resolve-peer-many.d.ts

@@ -0,0 +1,26 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+/**
+ * Get multiple `InputPeer`s at once,
+ * while also normalizing and removing
+ * peers that can't be normalized to that type.
+ *
+ * If a peer was not found, it will be skipped.
+ *
+ * Uses async pool internally, with a concurrent limit of 8
+ *
+ * @param peerIds  Peer Ids
+ * @param normalizer  Normalization function
+ */
+export declare function resolvePeerMany<T extends tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel>(client: ITelegramClient, peerIds: InputPeerLike[], normalizer: (obj: tl.TypeInputPeer) => T | null): Promise<T[]>;
+/**
+ * Get multiple `InputPeer`s at once.
+ *
+ * If a peer was not found, `null` will be returned instead
+ *
+ * Uses async pool internally, with a concurrent limit of 8
+ *
+ * @param peerIds  Peer Ids
+ */
+export declare function resolvePeerMany(client: ITelegramClient, peerIds: InputPeerLike[]): Promise<(tl.TypeInputPeer | null)[]>;

package/highlevel/methods/users/resolve-peer.d.ts

@@ -0,0 +1,19 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+/**
+ * Get the `InputPeer` of a known peer id.
+ * Useful when an `InputPeer` is needed in Raw API.
+ *
+ * @param peerId  The peer identifier that you want to extract the `InputPeer` from.
+ * @param force  Whether to force re-fetch the peer from the server (only for usernames and phone numbers)
+ */
+export declare function resolvePeer(client: ITelegramClient, peerId: InputPeerLike, force?: boolean): Promise<tl.TypeInputPeer>;
+/**
+ * Shorthand for `resolvePeer` that converts the input peer to `InputUser`.
+ */
+export declare function resolveUser(client: ITelegramClient, peerId: InputPeerLike, force?: boolean): Promise<tl.TypeInputUser>;
+/**
+ * Shorthand for `resolvePeer` that converts the input peer to `InputChannel`.
+ */
+export declare function resolveChannel(client: ITelegramClient, peerId: InputPeerLike, force?: boolean): Promise<tl.TypeInputChannel>;

package/highlevel/methods/users/set-global-ttl.d.ts

@@ -0,0 +1,8 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Changes the current default value of the Time-To-Live setting,
+ * applied to all new chats.
+ *
+ * @param period  New TTL period, in seconds (or 0 to disable)
+ */
+export declare function setGlobalTtl(client: ITelegramClient, period: number): Promise<void>;

package/highlevel/methods/users/set-my-birthday.d.ts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Set or remove current user's birthday.
+ */
+export declare function setMyBirthday(client: ITelegramClient, birthday: {
+    /** Birthday day */
+    day: number;
+    /** Birthday month */
+    month: number;
+    /** Birthday year (optional) */
+    year?: number;
+} | null): Promise<void>;

package/highlevel/methods/users/set-my-emoji-status.d.ts

@@ -0,0 +1,13 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Set an emoji status for the current user
+ *
+ * @param emoji  Custom emoji ID or `null` to remove the emoji
+ */
+export declare function setMyEmojiStatus(client: ITelegramClient, emoji: tl.Long | null, params?: {
+    /**
+     * Date when the emoji status should expire (only if `emoji` is not `null`)
+     */
+    until?: number | Date;
+}): Promise<void>;

package/highlevel/methods/users/set-my-profile-photo.d.ts

@@ -0,0 +1,16 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputFileLike, Photo } from '../../types/index.js';
+/**
+ * Set a new profile photo or video for the current user.
+ *
+ * You can also pass a file ID or an InputPhoto to re-use existing photo.
+ */
+export declare function setMyProfilePhoto(client: ITelegramClient, params: {
+    /** Media type (photo or video) */
+    type: 'photo' | 'video';
+    /** Input media file */
+    media: InputFileLike | tl.TypeInputPhoto;
+    /** When `type = video`, timestamp in seconds which will be shown as a static preview. */
+    previewSec?: number;
+}): Promise<Photo>;

package/highlevel/methods/users/set-my-username.d.ts

@@ -0,0 +1,11 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/index.js';
+/**
+ * Change username of the current user.
+ *
+ * Note that bots usernames must be changed through
+ * bot support or re-created from scratch.
+ *
+ * @param username  New username (5-32 chars, allowed chars: `a-zA-Z0-9_`), or `null` to remove
+ */
+export declare function setMyUsername(client: ITelegramClient, username: string | null): Promise<User>;

package/highlevel/methods/users/set-offline.d.ts

@@ -0,0 +1,7 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Change user status to offline or online
+ *
+ * @param offline  Whether the user is currently offline
+ */
+export declare function setOffline(client: ITelegramClient, offline?: boolean): Promise<void>;

package/highlevel/methods/users/unblock-user.d.ts

@@ -0,0 +1,8 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Unblock a user
+ *
+ * @param id  User ID, username or phone number
+ */
+export declare function unblockUser(client: ITelegramClient, id: InputPeerLike): Promise<void>;

package/highlevel/methods/users/update-profile.d.ts

@@ -0,0 +1,23 @@
+import { ITelegramClient } from '../../client.types.js';
+import { User } from '../../types/index.js';
+/**
+ * Update your profile details.
+ *
+ * Only pass fields that you want to change.
+ *
+ * @param params
+ */
+export declare function updateProfile(client: ITelegramClient, params: {
+    /**
+     * New first name
+     */
+    firstName?: string;
+    /**
+     * New last name. Pass `''` (empty string) to remove it
+     */
+    lastName?: string;
+    /**
+     * New bio (max 70 chars). Pass `''` (empty string) to remove it
+     */
+    bio?: string;
+}): Promise<User>;

package/highlevel/storage/provider.d.ts

@@ -0,0 +1,7 @@
+import { IMtStorageProvider } from '../../storage/provider.js';
+import { IPeersRepository } from './repository/peers.js';
+import { IReferenceMessagesRepository } from './repository/ref-messages.js';
+export interface ITelegramStorageProvider extends IMtStorageProvider {
+    readonly peers: IPeersRepository;
+    readonly refMessages: IReferenceMessagesRepository;
+}

package/highlevel/storage/repository/peers.d.ts

@@ -0,0 +1,32 @@
+import { MaybePromise } from '../../../types/utils.js';
+export declare namespace IPeersRepository {
+    /** Information about a cached peer */
+    interface PeerInfo {
+        /** Peer marked ID */
+        id: number;
+        /** Peer access hash, as a fast string representation */
+        accessHash: string;
+        /** Peer usernames, if any */
+        usernames: string[];
+        /** Timestamp (in seconds) when the peer was last updated */
+        updated: number;
+        /** Peer phone number, if available */
+        phone?: string;
+        /**
+         * Complete information about the peer,
+         * serialization of {@link tl.TypeUser} or {@link tl.TypeChat}
+         */
+        complete: Uint8Array;
+    }
+}
+export interface IPeersRepository {
+    /** Store the given peer */
+    store: (peer: IPeersRepository.PeerInfo) => MaybePromise<void>;
+    /** Find a peer by their `id` */
+    getById: (id: number) => MaybePromise<IPeersRepository.PeerInfo | null>;
+    /** Find a peer by their username (where `usernames` includes `username`) */
+    getByUsername: (username: string) => MaybePromise<IPeersRepository.PeerInfo | null>;
+    /** Find a peer by their `phone` */
+    getByPhone: (phone: string) => MaybePromise<IPeersRepository.PeerInfo | null>;
+    deleteAll: () => MaybePromise<void>;
+}

package/highlevel/storage/repository/ref-messages.d.ts

@@ -0,0 +1,20 @@
+import { MaybePromise } from '../../../types/utils.js';
+export interface IReferenceMessagesRepository {
+    /** Store a reference message */
+    store: (peerId: number, chatId: number, msgId: number) => MaybePromise<void>;
+    /**
+     * Get the reference message for the given `peerId`.
+     *
+     * If more than one reference message is stored for the given `peerId`,
+     * the one with the highest `msgId` should be returned, but this is not
+     * really important.
+     */
+    getByPeer: (peerId: number) => MaybePromise<[number, number] | null>;
+    /**
+     * Delete reference messages given the `chatId`
+     * where `msgId` is one of `msgIds`
+     */
+    delete: (chatId: number, msgIds: number[]) => MaybePromise<void>;
+    deleteByPeer: (peerId: number) => MaybePromise<void>;
+    deleteAll: () => MaybePromise<void>;
+}

package/highlevel/storage/service/current-user.d.ts

@@ -0,0 +1,23 @@
+import { tl } from '@mtcute/tl';
+import { IKeyValueRepository } from '../../../storage/repository/key-value.js';
+import { ServiceOptions, BaseService } from '../../../storage/service/base.js';
+export interface CurrentUserInfo {
+    userId: number;
+    isBot: boolean;
+    isPremium: boolean;
+    usernames: string[];
+}
+export declare class CurrentUserService extends BaseService {
+    private _kv;
+    constructor(_kv: IKeyValueRepository, opts: ServiceOptions);
+    private _cached?;
+    store(info: CurrentUserInfo | null): Promise<void>;
+    storeFrom(user: tl.TypeUser): Promise<CurrentUserInfo>;
+    fetch(): Promise<CurrentUserInfo | null>;
+    getCached(safe?: boolean): CurrentUserInfo | null;
+    update(params: {
+        username?: string;
+        usernames?: string[];
+        isPremium?: boolean;
+    }): Promise<void>;
+}

package/highlevel/storage/service/peers.d.ts

@@ -0,0 +1,23 @@
+import { tl } from '@mtcute/tl';
+import { ServiceOptions, BaseService } from '../../../storage/service/base.js';
+import { IPeersRepository } from '../repository/peers.js';
+import { RefMessagesService } from './ref-messages.js';
+export interface PeersServiceOptions {
+    cacheSize?: number;
+    updatesWriteInterval?: number;
+}
+export declare class PeersService extends BaseService {
+    private options;
+    private _peers;
+    private _refs;
+    private _cache;
+    private _pendingWrites;
+    constructor(options: PeersServiceOptions, _peers: IPeersRepository, _refs: RefMessagesService, common: ServiceOptions);
+    updatePeersFrom(obj: tl.TlObject | tl.TlObject[]): Promise<boolean>;
+    store(peer: tl.TypeUser | tl.TypeChat): Promise<void>;
+    private _returnCaching;
+    getById(id: number, allowRefs?: boolean): Promise<tl.TypeInputPeer | null>;
+    getByPhone(phone: string): Promise<tl.TypeInputPeer | null>;
+    getByUsername(username: string): Promise<tl.TypeInputPeer | null>;
+    getCompleteById(id: number): Promise<tl.TypeUser | tl.TypeChat | null>;
+}

package/highlevel/storage/service/ref-messages.d.ts

@@ -0,0 +1,15 @@
+import { ServiceOptions, BaseService } from '../../../storage/service/base.js';
+import { IReferenceMessagesRepository } from '../repository/ref-messages.js';
+export interface RefMessagesServiceOptions {
+    cacheSize?: number;
+}
+export declare class RefMessagesService extends BaseService {
+    readonly options: RefMessagesServiceOptions;
+    readonly _refs: IReferenceMessagesRepository;
+    private _cache;
+    constructor(options: RefMessagesServiceOptions, _refs: IReferenceMessagesRepository, common: ServiceOptions);
+    store(peerId: number, chatId: number, msgId: number): Promise<void>;
+    getForPeer(peerId: number): Promise<[number, number] | null>;
+    delete(chatId: number, msgIds: number[]): Promise<void>;
+    deleteByPeer(peerId: number): Promise<void>;
+}

package/highlevel/storage/service/updates.d.ts

@@ -0,0 +1,16 @@
+import { IKeyValueRepository } from '../../../storage/repository/key-value.js';
+import { ServiceOptions, BaseService } from '../../../storage/service/base.js';
+export declare class UpdatesStateService extends BaseService {
+    readonly _kv: IKeyValueRepository;
+    constructor(_kv: IKeyValueRepository, opts: ServiceOptions);
+    private _getInt;
+    private _setInt;
+    getState(): Promise<[number, number, number, number] | null>;
+    setPts(pts: number): Promise<void>;
+    setQts(qts: number): Promise<void>;
+    setDate(date: number): Promise<void>;
+    setSeq(seq: number): Promise<void>;
+    getChannelPts(channelId: number): Promise<number | null>;
+    setChannelPts(channelId: number, pts: number): Promise<void>;
+    setManyChannelPts(cpts: Map<number, number>): Promise<void>;
+}

package/highlevel/storage/storage.d.ts

@@ -0,0 +1,27 @@
+import { StorageManager } from '../../storage/storage.js';
+import { PublicPart } from '../../types/utils.js';
+import { ITelegramStorageProvider } from './provider.js';
+import { CurrentUserService } from './service/current-user.js';
+import { PeersServiceOptions, PeersService } from './service/peers.js';
+import { RefMessagesServiceOptions, RefMessagesService } from './service/ref-messages.js';
+import { UpdatesStateService } from './service/updates.js';
+interface TelegramStorageManagerOptions {
+    provider: ITelegramStorageProvider;
+}
+/** @internal */
+export interface TelegramStorageManagerExtraOptions {
+    refMessages?: RefMessagesServiceOptions;
+    peers?: PeersServiceOptions;
+}
+export declare class TelegramStorageManager {
+    private mt;
+    private options;
+    private provider;
+    readonly updates: UpdatesStateService;
+    readonly self: PublicPart<CurrentUserService>;
+    readonly refMsgs: RefMessagesService;
+    readonly peers: PublicPart<PeersService>;
+    constructor(mt: StorageManager, options: TelegramStorageManagerOptions & TelegramStorageManagerExtraOptions);
+    clear(withAuthKeys?: boolean): Promise<void>;
+}
+export {};

package/highlevel/types/auth/sent-code.d.ts

@@ -0,0 +1,56 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Type describing code delivery type.
+ * - `app`: Code is delivered via Telegram account
+ * - `sms`: Code is sent via SMS
+ * - `call`: Code is sent via voice call
+ * - `flash_call`: Code is the last 5 digits of the caller's phone number
+ * - `missed_call`: Code is the last 5 digits of the caller's phone number
+ * - `email`: Code is sent via Email
+ * - `email_required`: Code sending via email setup is required
+ * - `fragment`: Code is sent via Fragment anonymous numbers
+ * - `firebase`: Code is sent via Firebase
+ * - `sms_word`, `sms_phrase`: Code is sent via SMS with a word/phrase (see {@link SentCode#beginning})
+ * - `success`: Code is not needed, you're already logged in (only for future auth tokens)
+ */
+export type SentCodeDeliveryType = 'app' | 'sms' | 'call' | 'flash_call' | 'missed_call' | 'email' | 'email_required' | 'fragment' | 'firebase' | 'sms_word' | 'sms_phrase' | 'success';
+/**
+ * Type describing next code delivery type.
+ * See {@link DeliveryType} for information on values.
+ *
+ * Additionally, can be `none` if no more types are available
+ */
+export type NextCodeDeliveryType = Exclude<SentCodeDeliveryType, 'app'> | 'none';
+/**
+ * Information about sent confirmation code
+ */
+export declare class SentCode {
+    readonly raw: tl.auth.RawSentCode;
+    constructor(raw: tl.auth.RawSentCode);
+    /**
+     * Type of currently sent confirmation code
+     */
+    get type(): SentCodeDeliveryType;
+    /**
+     * Type of the confirmation code that will be sent
+     * if you call {@link TelegramClient.resendCode}.
+     */
+    get nextType(): NextCodeDeliveryType;
+    /**
+     * Confirmation code identifier used for the next authorization steps
+     * (like {@link TelegramClient.signIn} and {@link TelegramClient.signUp})
+     */
+    get phoneCodeHash(): string;
+    /**
+     * Delay in seconds to wait before calling {@link TelegramClient.resendCode}
+     */
+    get timeout(): number;
+    /**
+     * If the code is sent via SMS with a word/phrase, this field *may* contain the beginning of the message
+     */
+    get beginning(): string | undefined;
+    /**
+     * Length of the code (0 for flash calls)
+     */
+    get length(): number;
+}

package/highlevel/types/bots/command-scope/inner.d.ts

@@ -0,0 +1,54 @@
+import { tl } from '@mtcute/tl';
+import { InputPeerLike } from '../../peers/index.js';
+/**
+ * Intermediate bot scope, that is converted to
+ * TL type `BotCommandScope` by the respective functions.
+ *
+ * Used to avoid manually resolving peers.
+ */
+export type IntermediateScope = {
+    type: 'peer' | 'peer_admins';
+    peer: InputPeerLike;
+} | {
+    type: 'member';
+    chat: InputPeerLike;
+    user: InputPeerLike;
+};
+/**
+ * Default commands scope.
+ *
+ * Used if no commands with a narrower scope are available.
+ */
+export declare const default_: tl.RawBotCommandScopeDefault;
+/**
+ * Scope that covers all private chats
+ */
+export declare const allPrivate: tl.RawBotCommandScopeUsers;
+/**
+ * Scope that covers all group chats (both legacy and supergroups)
+ */
+export declare const allGroups: tl.RawBotCommandScopeChats;
+/**
+ * Scope that covers all group chat administrators (both legacy and supergroups)
+ */
+export declare const allGroupAdmins: tl.RawBotCommandScopeChatAdmins;
+/**
+ * Scope that covers a specific peer (a single user in PMs,
+ * or all users of a legacy group or a supergroup)
+ */
+export declare function peer(peer: InputPeerLike): IntermediateScope;
+/**
+ * Scope that covers admins in a specific group
+ */
+export declare function groupAdmins(peer: InputPeerLike): IntermediateScope;
+/**
+ * Scope that covers a specific user in a specific group
+ */
+export declare function groupMember(chat: InputPeerLike, user: InputPeerLike): IntermediateScope;
+/**
+ * Helper function to create a bot command object
+ *
+ * @param command  Bot command (without slash)
+ * @param description  Command description
+ */
+export declare function cmd(command: string, description: string): tl.RawBotCommand;

package/highlevel/types/bots/game-high-score.d.ts

@@ -0,0 +1,23 @@
+import { tl } from '@mtcute/tl';
+import { PeersIndex } from '../peers/peers-index.js';
+import { User } from '../peers/user.js';
+/**
+ * Game high score
+ */
+export declare class GameHighScore {
+    readonly raw: tl.RawHighScore;
+    readonly _peers: PeersIndex;
+    constructor(raw: tl.RawHighScore, _peers: PeersIndex);
+    /**
+     * User who has scored this score
+     */
+    get user(): User;
+    /**
+     * Position in the records list
+     */
+    get position(): number;
+    /**
+     * Score
+     */
+    get score(): number;
+}

package/highlevel/types/bots/inline-message/factories.d.ts

@@ -0,0 +1,47 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../../client.types.js';
+import { InputText } from '../../../types/misc/entities.js';
+import { InputInlineMessage, InputInlineMessageContact, InputInlineMessageGame, InputInlineMessageGeo, InputInlineMessageGeoLive, InputInlineMessageMedia, InputInlineMessageText, InputInlineMessageVenue, InputInlineMessageWebpage } from './types.js';
+/**
+ * Create a text inline message
+ *
+ * @param text  Message text
+ * @param params
+ */
+export declare function text(text: InputText, params?: Omit<InputInlineMessageText, 'type' | 'text'>): InputInlineMessageText;
+/**
+ * Create an inline message containing
+ * media from the result
+ */
+export declare function media(params?: Omit<InputInlineMessageMedia, 'type'>): InputInlineMessageMedia;
+/**
+ * Create an inline message containing a geolocation
+ *
+ * @param params  Additional parameters
+ */
+export declare function geo(params: Omit<InputInlineMessageGeo, 'type'>): InputInlineMessageGeo;
+/**
+ * Create an inline message containing a live geolocation
+ *
+ * @param params  Additional parameters
+ */
+export declare function geoLive(params: Omit<InputInlineMessageGeoLive, 'type'>): InputInlineMessageGeoLive;
+/**
+ * Create an inline message containing a venue
+ */
+export declare function venue(params: Omit<InputInlineMessageVenue, 'type'>): InputInlineMessageVenue;
+/**
+ * Create an inline message containing a game
+ * from the inline result
+ */
+export declare function game(params: Omit<InputInlineMessageGame, 'type'>): InputInlineMessageGame;
+/**
+ * Create an inline message containing a contact
+ */
+export declare function contact(params: Omit<InputInlineMessageContact, 'type'>): InputInlineMessageContact;
+/**
+ * Create an inline message containing a webpage
+ */
+export declare function webpage(params: Omit<InputInlineMessageWebpage, 'type'>): InputInlineMessageWebpage;
+/** @internal */
+export declare function _convertToTl(client: ITelegramClient, obj: InputInlineMessage): Promise<tl.TypeInputBotInlineMessage>;