@mtcute/core 0.18.0-rc.5 → 0.18.0

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

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

@@ -0,0 +1,10 @@
+import * as BotCommands from './inner.js';
+export { 
+/**
+ * Helper constants and builder functions for methods
+ * related to bot commands.
+ *
+ * You can learn more about bot command scopes in
+ * [Bot API docs](https://core.telegram.org/bots/api#botcommandscope)
+ */
+BotCommands, };

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

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

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

@@ -0,0 +1,6 @@
+export * from './command-scope/index.js';
+export * from './game-high-score.js';
+export * from './inline-message/index.js';
+export * from './inline-result/index.js';
+export * from './keyboards/index.js';
+export * from './webview.js';

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

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

package/highlevel/types/bots/inline-message/index.d.cts

@@ -0,0 +1,3 @@
+import * as BotInlineMessage from './factories.js';
+export * from './types.js';
+export { BotInlineMessage };

package/highlevel/types/bots/inline-message/types.d.cts

@@ -0,0 +1,114 @@
+import { InputMediaContact, InputMediaGeo, InputMediaGeoLive, InputMediaVenue, InputMediaWebpage } from '../../media/index.js';
+import { InputText } from '../../misc/entities.js';
+import { ReplyMarkup } from '../index.js';
+/**
+ * Inline message containing only text
+ */
+export interface InputInlineMessageText {
+    type: 'text';
+    /**
+     * Text of the message
+     */
+    text: InputText;
+    /**
+     * Message reply markup
+     */
+    replyMarkup?: ReplyMarkup;
+    /**
+     * Whether to disable links preview in this message
+     */
+    disableWebPreview?: boolean;
+    /**
+     * Whether to invert media position.
+     *
+     * Currently only supported for web previews and makes the
+     * client render the preview above the caption and not below.
+     */
+    invertMedia?: boolean;
+}
+/**
+ * Inline message containing media, which is automatically
+ * inferred from the result itself.
+ */
+export interface InputInlineMessageMedia {
+    type: 'media';
+    /**
+     * Caption for the media
+     */
+    text?: InputText;
+    /**
+     * Message reply markup
+     */
+    replyMarkup?: ReplyMarkup;
+    /**
+     * Whether to invert media position.
+     *
+     * Currently only supported for web previews and makes the
+     * client render the preview above the caption and not below.
+     */
+    invertMedia?: boolean;
+}
+/**
+ * Inline message containing a geolocation
+ */
+export interface InputInlineMessageGeo extends InputMediaGeo {
+    /**
+     * Message's reply markup
+     */
+    replyMarkup?: ReplyMarkup;
+}
+/**
+ * Inline message containing a live geolocation
+ */
+export interface InputInlineMessageGeoLive extends InputMediaGeoLive {
+    /**
+     * Message's reply markup
+     */
+    replyMarkup?: ReplyMarkup;
+}
+/**
+ * Inline message containing a venue
+ */
+export interface InputInlineMessageVenue extends InputMediaVenue {
+    /**
+     * Message's reply markup
+     */
+    replyMarkup?: ReplyMarkup;
+}
+/**
+ * Inline message containing a game
+ */
+export interface InputInlineMessageGame {
+    type: 'game';
+    /**
+     * Message's reply markup
+     */
+    replyMarkup?: ReplyMarkup;
+}
+/**
+ * Inline message containing a contact
+ */
+export interface InputInlineMessageContact extends InputMediaContact {
+    /**
+     * Message's reply markup
+     */
+    replyMarkup?: ReplyMarkup;
+}
+export interface InputInlineMessageWebpage extends InputMediaWebpage {
+    /**
+     * Text of the message
+     */
+    text: InputText;
+    /**
+     * Message reply markup
+     */
+    replyMarkup?: ReplyMarkup;
+    /**
+     * Whether to invert media position.
+     *
+     * Currently only supported for web previews and makes the
+     * client render the preview above the caption and not below.
+     */
+    invertMedia?: boolean;
+}
+export type InputInlineMessage = InputInlineMessageText | InputInlineMessageMedia | InputInlineMessageGeo | InputInlineMessageGeoLive | InputInlineMessageVenue | InputInlineMessageGame | InputInlineMessageContact | InputInlineMessageWebpage;

package/highlevel/types/bots/inline-result/factories.d.cts

@@ -0,0 +1,97 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../../client.types.js';
+import { InputInlineResult, InputInlineResultArticle, InputInlineResultAudio, InputInlineResultContact, InputInlineResultFile, InputInlineResultGame, InputInlineResultGeo, InputInlineResultGif, InputInlineResultPhoto, InputInlineResultSticker, InputInlineResultVenue, InputInlineResultVideo, InputInlineResultVoice } from './types.js';
+/**
+ * Create an inline result containing an article
+ *
+ * @param id  Inline result ID
+ * @param params  Article
+ */
+export declare function article(id: string, params: Omit<InputInlineResultArticle, 'type' | 'id'>): InputInlineResultArticle;
+/**
+ * Create an inline result containing a GIF
+ *
+ * @param id  Inline result ID
+ * @param media  GIF animation
+ * @param params  Additional parameters
+ */
+export declare function gif(id: string, media: string | tl.RawInputWebDocument | tl.RawInputDocument, params?: Omit<InputInlineResultGif, 'type' | 'id' | 'media'>): InputInlineResultGif;
+/**
+ * Create an inline result containing a video
+ *
+ * @param id  Inline result ID
+ * @param media  Video
+ * @param params  Additional parameters
+ */
+export declare function video(id: string, media: string | tl.RawInputWebDocument | tl.RawInputDocument, params: Omit<InputInlineResultVideo, 'type' | 'id' | 'media'>): InputInlineResultVideo;
+/**
+ * Create an inline result containing an audio file
+ *
+ * @param id  Inline result ID
+ * @param media  Audio file
+ * @param params  Additional parameters
+ */
+export declare function audio(id: string, media: string | tl.RawInputWebDocument | tl.RawInputDocument, params: Omit<InputInlineResultAudio, 'type' | 'id' | 'media'>): InputInlineResultAudio;
+/**
+ * Create an inline result containing a voice note
+ *
+ * @param id  Inline result ID
+ * @param media  Voice note
+ * @param params  Additional parameters
+ */
+export declare function voice(id: string, media: string | tl.RawInputWebDocument | tl.RawInputDocument, params: Omit<InputInlineResultVoice, 'type' | 'id' | 'media'>): InputInlineResultVoice;
+/**
+ * Create an inline result containing a photo
+ *
+ * @param id  Inline result ID
+ * @param media  Photo
+ * @param params  Additional parameters
+ */
+export declare function photo(id: string, media: string | tl.RawInputWebDocument | tl.RawInputPhoto, params?: Omit<InputInlineResultPhoto, 'type' | 'id' | 'media'>): InputInlineResultPhoto;
+/**
+ * Create an inline result containing a sticker
+ *
+ * @param id  Inline result ID
+ * @param media  Sticker
+ */
+export declare function sticker(id: string, media: string | tl.RawInputDocument): InputInlineResultSticker;
+/**
+ * Create an inline result containing a document
+ * (only PDF and ZIP are supported when using URL)
+ *
+ * @param id  Inline result ID
+ * @param media  Document
+ * @param params  Additional parameters
+ */
+export declare function file(id: string, media: string | tl.RawInputWebDocument | tl.RawInputDocument, params: Omit<InputInlineResultFile, 'type' | 'id' | 'media'>): InputInlineResultFile;
+/**
+ * Create an inline result containing a geolocation
+ *
+ * @param id  Inline result ID
+ * @param params  Additional parameters
+ */
+export declare function geo(id: string, params: Omit<InputInlineResultGeo, 'type' | 'id'>): InputInlineResultGeo;
+/**
+ * Create an inline result containing a venue
+ *
+ * @param id  Inline result ID
+ * @param params  Venue parameters
+ */
+export declare function venue(id: string, params: Omit<InputInlineResultVenue, 'type' | 'id'>): InputInlineResultVenue;
+/**
+ * Create an inline result containing a contact
+ *
+ * @param id  Inline result ID
+ * @param params  Contact parameters
+ */
+export declare function contact(id: string, params: Omit<InputInlineResultContact, 'type' | 'id'>): InputInlineResultContact;
+/**
+ * Create an inline result containing a game
+ *
+ * @param id  Inline result ID
+ * @param shortName  Short name of the game
+ * @param params  Additional parameters
+ */
+export declare function game(id: string, shortName: string, params?: Omit<InputInlineResultGame, 'type' | 'id' | 'shortName'>): InputInlineResultGame;
+/** @internal */
+export declare function _convertToTl(client: ITelegramClient, results: InputInlineResult[]): Promise<[boolean, tl.TypeInputBotInlineResult[]]>;

package/highlevel/types/bots/inline-result/index.d.cts

@@ -0,0 +1,3 @@
+import * as BotInline from './factories.js';
+export * from './types.js';
+export { BotInline };