@mtcute/core 0.18.0-rc.5 → 0.18.0

package/highlevel/methods/messages/send-common.d.cts

@@ -0,0 +1,122 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/messages/message.js';
+import { TextWithEntities } from '../../types/misc/entities.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+export interface CommonSendParams {
+    /**
+     * Message to reply to. Either a message object or message ID.
+     *
+     * For forums - can also be an ID of the topic (i.e. its top message ID)
+     *
+     * Can also be a message from another chat, in which case a quote will be sent.
+     */
+    replyTo?: number | Message;
+    /**
+     * Whether to throw an error if {@link replyTo}
+     * message does not exist.
+     *
+     * If that message was not found, `NotFoundError` is thrown,
+     * with `text` set to `MESSAGE_NOT_FOUND`.
+     *
+     * Incurs an additional request, so only use when really needed.
+     *
+     * @default  `false`
+     */
+    mustReply?: boolean;
+    /**
+     * Message to comment to. Either a message object or message ID.
+     *
+     * This overwrites `replyTo` if it was passed
+     */
+    commentTo?: number | Message;
+    /**
+     * Story to reply to.
+     *
+     * Must be the story sent by the peer you are sending the message to.
+     *
+     * Can't be used together with {@link replyTo} or {@link commentTo}.
+     */
+    replyToStory?: number;
+    /**
+     * Quoted text. Must be exactly contained in the message
+     * being quoted to be accepted by the server (as well as entities)
+     */
+    quote?: TextWithEntities;
+    /**
+     * Offset of the start of the quote in the message.
+     */
+    quoteOffset?: number;
+    /**
+     * Whether to send this message silently.
+     */
+    silent?: boolean;
+    /**
+     * If set, the message will be scheduled to this date.
+     * When passing a number, a UNIX time in ms is expected.
+     *
+     * You can also pass `online` - this will send the message
+     * once the peer is online. Note that this requires that
+     * peer's online status to be visible to you.
+     */
+    schedule?: Date | number | 'online';
+    /**
+     * Whether to clear draft after sending this message.
+     *
+     * @default  `false`
+     */
+    clearDraft?: boolean;
+    /**
+     * Whether to disallow further forwards of this message.
+     *
+     * Only for bots, works even if the target chat does not
+     * have content protection.
+     */
+    forbidForwards?: boolean;
+    /**
+     * Peer to use when sending the message.
+     */
+    sendAs?: InputPeerLike;
+    /**
+     * If passed, instead of sending the message, it will be saved into the
+     * given quick reply shortcut (either its ID or its shortcut string).
+     */
+    quickReply?: number | string;
+    /**
+     * Whether to dispatch the returned message to the client's update handler.
+     * Doesn't follow `disableNoDispatch`
+     */
+    shouldDispatch?: true;
+    /**
+     * Unique identifier of the business connection on behalf of which
+     * the message will be sent
+     */
+    businessConnectionId?: string;
+    /**
+     * Bots only: if set, allows sending up to 1000 messages per second,
+     * ignoring broadcasting limits for a fee of 0.1 Telegram Stars per message.
+     * The Stars will be withdrawn from the bot's balance.
+     */
+    allowPaidFloodskip?: boolean;
+    /**
+     * ID of a message effect to use when sending the message
+     * (see {@link TelegramClient.getAvailableMessageEffects})
+     */
+    effect?: tl.Long;
+}
+/**
+ * @internal
+ * @noemit
+ */
+export declare function _normalizeQuickReplyShortcut(shortcut: number | string | undefined): tl.TypeInputQuickReplyShortcut | undefined;
+/**
+ * @internal
+ * @noemit
+ */
+export declare function _processCommonSendParameters(client: ITelegramClient, chatId: InputPeerLike, params: CommonSendParams): Promise<{
+    peer: tl.TypeInputPeer;
+    replyTo: tl.TypeInputReplyTo | undefined;
+    scheduleDate: number | undefined;
+    quickReplyShortcut: tl.TypeInputQuickReplyShortcut | undefined;
+    chainId: string;
+}>;

package/highlevel/methods/messages/send-copy-group.d.cts

@@ -0,0 +1,21 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/messages/message.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+import { CommonSendParams } from './send-common.js';
+export interface SendCopyGroupParams extends CommonSendParams {
+    /** Destination chat ID */
+    toChatId: InputPeerLike;
+}
+/**
+ * Copy a message group (i.e. send the same message group, but do not forward it).
+ *
+ * Note that all the provided messages must be in the same message group
+ */
+export declare function sendCopyGroup(client: ITelegramClient, params: SendCopyGroupParams & ({
+    /** Source chat ID */
+    fromChatId: InputPeerLike;
+    /** Message IDs to forward */
+    messages: number[];
+} | {
+    messages: Message[];
+})): Promise<Message[]>;

package/highlevel/methods/messages/send-copy.d.cts

@@ -0,0 +1,32 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, InputText, Message, ReplyMarkup } from '../../types/index.js';
+import { CommonSendParams } from './send-common.js';
+export interface SendCopyParams extends CommonSendParams {
+    /** Target chat ID */
+    toChatId: InputPeerLike;
+    /**
+     * New message caption (only used for media)
+     */
+    caption?: InputText;
+    /**
+     * For bots: inline or reply markup or an instruction
+     * to hide a reply keyboard or to force a reply.
+     */
+    replyMarkup?: ReplyMarkup;
+}
+/**
+ * Copy a message (i.e. send the same message, but do not forward it).
+ *
+ * Note that if the message contains a webpage,
+ * it will be copied simply as a text message,
+ * and if the message contains an invoice,
+ * it can't be copied.
+ */
+export declare function sendCopy(client: ITelegramClient, params: SendCopyParams & ({
+    /** Source chat ID */
+    fromChatId: InputPeerLike;
+    /** Message ID to forward */
+    message: number;
+} | {
+    message: Message;
+})): Promise<Message>;

package/highlevel/methods/messages/send-media-group.d.cts

@@ -0,0 +1,35 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputMediaLike } from '../../types/media/input-media/types.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+import { CommonSendParams } from './send-common.js';
+import { Message } from '../../types/messages/message.js';
+/**
+ * Send a group of media.
+ *
+ * To add a caption to the group, add caption to the first
+ * media in the group and don't add caption for any other.
+ *
+ * @param chatId  ID of the chat, its username, phone or `"me"` or `"self"`
+ * @param medias  Medias contained in the message.
+ * @param params  Additional sending parameters
+ * @link InputMedia
+ */
+export declare function sendMediaGroup(client: ITelegramClient, chatId: InputPeerLike, medias: (InputMediaLike | string)[], params?: CommonSendParams & {
+    /**
+     * 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;
+    /**
+     * Function that will be called after some part has been uploaded.
+     * Only used when a file that requires uploading is passed,
+     * and not used when uploading a thumbnail.
+     *
+     * @param index  Index of the media in the original array
+     * @param uploaded  Number of bytes already uploaded
+     * @param total  Total file size
+     */
+    progressCallback?: (index: number, uploaded: number, total: number) => void;
+}): Promise<Message[]>;

package/highlevel/methods/messages/send-media.d.cts

@@ -0,0 +1,48 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ReplyMarkup } from '../../types/bots/keyboards/index.js';
+import { InputMediaLike } from '../../types/media/input-media/types.js';
+import { Message } from '../../types/messages/message.js';
+import { InputText } from '../../types/misc/entities.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+import { CommonSendParams } from './send-common.js';
+/**
+ * Send a single media (a photo or a document-based media)
+ *
+ * @param chatId  ID of the chat, its username, phone or `"me"` or `"self"`
+ * @param media
+ *     Media contained in the message. You can also pass TDLib
+ *     and Bot API compatible File ID, which will be wrapped
+ *     in {@link InputMedia.auto}
+ * @param params  Additional sending parameters
+ * @link InputMedia
+ */
+export declare function sendMedia(client: ITelegramClient, chatId: InputPeerLike, media: InputMediaLike | string, params?: CommonSendParams & {
+    /**
+     * For bots: inline or reply markup or an instruction
+     * to hide a reply keyboard or to force a reply.
+     */
+    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.
+     */
+    invert?: boolean;
+    /**
+     * Override caption for `media`.
+     *
+     * Can be used, for example. when using File IDs
+     * or when using existing InputMedia objects.
+     */
+    caption?: InputText;
+    /**
+     * Function that will be called after some part has been uploaded.
+     * Only used when a file that requires uploading is passed,
+     * and not used when uploading a thumbnail.
+     *
+     * @param uploaded  Number of bytes already uploaded
+     * @param total  Total file size
+     */
+    progressCallback?: (uploaded: number, total: number) => void;
+}): Promise<Message>;

package/highlevel/methods/messages/send-paid-reaction.d.cts

@@ -0,0 +1,24 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId, MessageReactions } from '../../types/index.js';
+/**
+ * Send a paid reaction using Telegram Stars.
+ *
+ * @returns
+ *   Message to which the reaction was sent, if available.
+ *   The message is normally available for users, but may not be available for bots in PMs.
+ */
+export declare function sendPaidReaction(client: ITelegramClient, params: InputMessageId & {
+    /** Whether to send the reaction anonymously */
+    anonymous?: boolean;
+    /**
+     * Number of reactions to send
+     *
+     * @default  1
+     */
+    count?: number;
+    /**
+     * Whether to dispatch the returned edit message event
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<MessageReactions>;

package/highlevel/methods/messages/send-quote.d.cts

@@ -0,0 +1,33 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/messages/message.js';
+import { InputPeerLike } from '../../types/peers/peer.js';
+import { sendMediaGroup } from './send-media-group.js';
+import { sendMedia } from './send-media.js';
+import { sendText } from './send-text.js';
+export type QuoteParamsFrom<T> = Omit<NonNullable<T>, 'quoteText' | 'quoteEntities'> & {
+    /**
+     * Destination chat ID, username, phone, `"me"` or `"self"`
+     *
+     * @default  `message.chat`
+     */
+    toChatId?: InputPeerLike;
+    /** Index of the first character to quote (inclusive) */
+    start: number;
+    /** Index of the last character to quote (exclusive) */
+    end: number;
+};
+/** Send a text in reply to a given quote */
+export declare function quoteWithText(client: ITelegramClient, message: Message, params: QuoteParamsFrom<Parameters<typeof sendText>[3]> & {
+    /** Text to send */
+    text: Parameters<typeof sendText>[2];
+}): ReturnType<typeof sendText>;
+/** Send a media in reply to a given quote */
+export declare function quoteWithMedia(client: ITelegramClient, message: Message, params: QuoteParamsFrom<Parameters<typeof sendMedia>[3]> & {
+    /** Media to send */
+    media: Parameters<typeof sendMedia>[2];
+}): ReturnType<typeof sendMedia>;
+/** Send a media group in reply to a given quote */
+export declare function quoteWithMediaGroup(client: ITelegramClient, message: Message, params: QuoteParamsFrom<Parameters<typeof sendMediaGroup>[3]> & {
+    /** Media group to send */
+    medias: Parameters<typeof sendMediaGroup>[2];
+}): ReturnType<typeof sendMediaGroup>;

package/highlevel/methods/messages/send-reaction.d.cts

@@ -0,0 +1,21 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId, InputReaction, Message } from '../../types/index.js';
+/**
+ * Send or remove a reaction.
+ *
+ * @returns
+ *   Message to which the reaction was sent, if available.
+ *   The message is normally available for users, but may not be available for bots in PMs.
+ */
+export declare function sendReaction(client: ITelegramClient, params: InputMessageId & {
+    /** Reaction emoji (or `null` to remove reaction) */
+    emoji?: MaybeArray<InputReaction> | null;
+    /** Whether to use a big reaction */
+    big?: boolean;
+    /**
+     * Whether to dispatch the returned edit message event
+     * to the client's update handler.
+     */
+    shouldDispatch?: true;
+}): Promise<Message | null>;

package/highlevel/methods/messages/send-reply.d.cts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+import { Message } from '../../types/messages/message.js';
+import { ParametersSkip2 } from '../../types/utils.js';
+import { sendMediaGroup } from './send-media-group.js';
+import { sendMedia } from './send-media.js';
+import { sendText } from './send-text.js';
+/** Send a text in reply to a given message */
+export declare function replyText(client: ITelegramClient, message: Message, ...params: ParametersSkip2<typeof sendText>): ReturnType<typeof sendText>;
+/** Send a media in reply to a given message */
+export declare function replyMedia(client: ITelegramClient, message: Message, ...params: ParametersSkip2<typeof sendMedia>): ReturnType<typeof sendMedia>;
+/** Send a media group in reply to a given message */
+export declare function replyMediaGroup(client: ITelegramClient, message: Message, ...params: ParametersSkip2<typeof sendMediaGroup>): ReturnType<typeof sendMediaGroup>;

package/highlevel/methods/messages/send-scheduled.d.cts

@@ -0,0 +1,14 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, Message } from '../../types/index.js';
+/**
+ * Send previously scheduled message(s)
+ *
+ * Note that if the message belongs to a media group,
+ * the entire group will be sent, and all the messages
+ * will be returned.
+ *
+ * @param peer  Chat where the messages were scheduled
+ * @param ids  ID(s) of the messages
+ */
+export declare function sendScheduled(client: ITelegramClient, peer: InputPeerLike, ids: MaybeArray<number>): Promise<Message[]>;

package/highlevel/methods/messages/send-text.d.cts

@@ -0,0 +1,31 @@
+import { ITelegramClient } from '../../client.types.js';
+import { ReplyMarkup } from '../../types/bots/keyboards/index.js';
+import { InputText } from '../../types/misc/entities.js';
+import { InputPeerLike } from '../../types/peers/index.js';
+import { CommonSendParams } from './send-common.js';
+import { Message } from '../../types/messages/message.js';
+/**
+ * Send a text message
+ *
+ * @param chatId  ID of the chat, its username, phone or `"me"` or `"self"`
+ * @param text  Text of the message
+ * @param params  Additional sending parameters
+ */
+export declare function sendText(client: ITelegramClient, chatId: InputPeerLike, text: InputText, params?: CommonSendParams & {
+    /**
+     * For bots: inline or reply markup or an instruction
+     * to hide a reply keyboard or to force a reply.
+     */
+    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;
+}): Promise<Message>;

package/highlevel/methods/messages/send-text.test.d.cts

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

package/highlevel/methods/messages/send-typing.d.cts

@@ -0,0 +1,32 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike, TypingStatus } from '../../types/index.js';
+export declare function _mapTypingStatus(status: Exclude<TypingStatus, 'interaction' | 'interaction_seen'>, progress?: number): tl.TypeSendMessageAction;
+/**
+ * Sends a current user/bot typing event
+ * to a conversation partner or group.
+ *
+ * This status is set for 6 seconds, and is
+ * automatically cancelled if you send a
+ * message.
+ *
+ * If you need a continuous typing status, use {@link setTyping} instead.
+ *
+ * @param chatId  Chat ID
+ * @param status  Typing status
+ * @param params
+ */
+export declare function sendTyping(client: ITelegramClient, chatId: InputPeerLike, status?: Exclude<TypingStatus, 'interaction' | 'interaction_seen'> | tl.TypeSendMessageAction, params?: {
+    /**
+     * For `upload_*` and history import actions, progress of the upload
+     */
+    progress?: number;
+    /**
+     * Unique identifier of the business connection on behalf of which the action will be sent
+     */
+    businessConnectionId?: string;
+    /**
+     * For comment threads, ID of the thread (i.e. top message)
+     */
+    threadId?: number;
+}): Promise<void>;

package/highlevel/methods/messages/send-vote.d.cts

@@ -0,0 +1,15 @@
+import { MaybeArray } from '../../../types/utils.js';
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId, Poll } from '../../types/index.js';
+/**
+ * Send or retract a vote in a poll.
+ */
+export declare function sendVote(client: ITelegramClient, params: InputMessageId & {
+    /**
+     * Selected options, or `null` to retract.
+     * You can pass indexes of the answers or the `Buffer`s
+     * representing them. In case of indexes, the poll will first
+     * be requested from the server.
+     */
+    options: null | MaybeArray<number | Uint8Array>;
+}): Promise<Poll>;

package/highlevel/methods/messages/set-typing.d.cts

@@ -0,0 +1,33 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/peers/peer.js';
+import { TypingStatus } from '../../types/peers/typing-status.js';
+export declare function _getTypingTimerId(peer: tl.TypeInputPeer, businessId?: string): string;
+/**
+ * Sets whether a user is typing in a specific chat
+ *
+ * This status is automatically renewed by mtcute until a further
+ * call with `cancel` is made, or a message is sent to the chat.
+ */
+export declare function setTyping(client: ITelegramClient, params: {
+    /** Chat ID where the user is currently typing */
+    peerId: InputPeerLike;
+    /**
+     * Typing status to send
+     *
+     * @default  `typing`
+     */
+    status?: Exclude<TypingStatus, 'interaction' | 'interaction_seen'> | tl.TypeSendMessageAction;
+    /**
+     * For `upload_*` and history import actions, progress of the upload
+     */
+    progress?: number;
+    /**
+     * Unique identifier of the business connection on behalf of which the action will be sent
+     */
+    businessConnectionId?: string;
+    /**
+     * For comment threads, ID of the thread (i.e. top message)
+     */
+    threadId?: number;
+}): Promise<void>;

package/highlevel/methods/messages/translate-message.d.cts

@@ -0,0 +1,11 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId, TextWithEntities } from '../../types/index.js';
+/**
+ * Translate message text to a given language.
+ *
+ * Returns `null` if it could not translate the message.
+ */
+export declare function translateMessage(client: ITelegramClient, params: InputMessageId & {
+    /** Target language (two-letter ISO 639-1 language code) */
+    toLanguage: string;
+}): Promise<TextWithEntities>;

package/highlevel/methods/messages/translate-text.d.cts

@@ -0,0 +1,9 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputText, TextWithEntities } from '../../types/misc/entities.js';
+/**
+ * Translate text to a given language.
+ *
+ * @param text  Text to translate
+ * @param toLanguage  Target language (two-letter ISO 639-1 language code)
+ */
+export declare function translateText(client: ITelegramClient, text: InputText, toLanguage: string): Promise<TextWithEntities>;

package/highlevel/methods/messages/unpin-all-messages.d.cts

@@ -0,0 +1,18 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputPeerLike } from '../../types/index.js';
+/**
+ * Unpin all pinned messages in a chat.
+ *
+ * @param chatId  Chat or user ID
+ */
+export declare function unpinAllMessages(client: ITelegramClient, chatId: InputPeerLike, params?: {
+    /**
+     * For forums - unpin only messages from the given topic
+     */
+    topicId?: number;
+    /**
+     * Whether to dispatch updates that will be generated by this call.
+     * Doesn't follow `disableNoDispatch`
+     */
+    shouldDispatch?: true;
+}): Promise<void>;

package/highlevel/methods/messages/unpin-message.d.cts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+import { InputMessageId } from '../../types/index.js';
+/**
+ * Unpin a message in a group, supergroup, channel or PM.
+ *
+ * For supergroups/channels, you must have appropriate permissions,
+ * either as an admin, or as default permissions
+ *
+ * @param chatId  Chat ID, username, phone number, `"self"` or `"me"`
+ * @param messageId  Message ID
+ */
+export declare function unpinMessage(client: ITelegramClient, params: InputMessageId): Promise<void>;

package/highlevel/methods/misc/chain-id.d.cts

@@ -0,0 +1,4 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+/** @internal */
+export declare function _getPeerChainId(client: ITelegramClient, peer: tl.TypeInputPeer, prefix?: string): string;

package/highlevel/methods/misc/get-collectible-info.d.cts

@@ -0,0 +1,6 @@
+import { ITelegramClient } from '../../client.types.js';
+import { CollectibleInfo } from '../../types/misc/collectible-info.js';
+/**
+ * Get information about a fragment collectible
+ */
+export declare function getCollectibleInfo(client: ITelegramClient, kind: 'phone' | 'username', item: string): Promise<CollectibleInfo>;

package/highlevel/methods/misc/init-takeout-session.d.cts

@@ -0,0 +1,9 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { TakeoutSession } from '../../types/index.js';
+/**
+ * Create a new takeout session
+ *
+ * @param params  Takeout session parameters
+ */
+export declare function initTakeoutSession(client: ITelegramClient, params: Omit<tl.account.RawInitTakeoutSessionRequest, '_'>): Promise<TakeoutSession>;

package/highlevel/methods/misc/normalize-privacy-rules.d.cts

@@ -0,0 +1,8 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputPrivacyRule } from '../../types/index.js';
+/**
+ * Normalize {@link InputPrivacyRule}[] to `tl.TypeInputPrivacyRule`,
+ * resolving the peers if needed.
+ */
+export declare function _normalizePrivacyRules(client: ITelegramClient, rules: InputPrivacyRule[]): Promise<tl.TypeInputPrivacyRule[]>;

package/highlevel/methods/misc/normalize-text.d.cts

@@ -0,0 +1,5 @@
+import { tl } from '@mtcute/tl';
+import { ITelegramClient } from '../../client.types.js';
+import { InputText } from '../../types/misc/entities.js';
+/** @internal */
+export declare function _normalizeInputText(client: ITelegramClient, input?: InputText): Promise<[string, tl.TypeMessageEntity[] | undefined]>;

package/highlevel/methods/misc/with-params.d.cts

@@ -0,0 +1,10 @@
+import { RpcCallOptions } from '../../../network/index.js';
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Wrap a client so that all RPC calls will use the specified parameters.
+ *
+ * @param client Client to wrap
+ * @param params RPC call parameters to use by default
+ * @returns The wrapped client
+ */
+export declare function withParams<T extends ITelegramClient>(client: T, params: RpcCallOptions): T;

package/highlevel/methods/password/change-cloud-password.d.cts

@@ -0,0 +1,12 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Change your 2FA password
+ */
+export declare function changeCloudPassword(client: ITelegramClient, params: {
+    /** Current password as plaintext */
+    currentPassword: string;
+    /** New password as plaintext */
+    newPassword: string;
+    /** Hint for the new password */
+    hint?: string;
+}): Promise<void>;

package/highlevel/methods/password/enable-cloud-password.d.cts

@@ -0,0 +1,17 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Enable 2FA password on your account
+ *
+ * Note that if you pass `email`, `EmailUnconfirmedError` may be
+ * thrown, and you should use {@link verifyPasswordEmail},
+ * {@link resendPasswordEmail} or {@link cancelPasswordEmail},
+ * and the call this method again
+ */
+export declare function enableCloudPassword(client: ITelegramClient, params: {
+    /** 2FA password as plaintext */
+    password: string;
+    /** Hint for the new password */
+    hint?: string;
+    /** Recovery email */
+    email?: string;
+}): Promise<void>;

package/highlevel/methods/password/password-email.d.cts

@@ -0,0 +1,15 @@
+import { ITelegramClient } from '../../client.types.js';
+/**
+ * Verify an email to use as 2FA recovery method
+ *
+ * @param code  Code which was sent via email
+ */
+export declare function verifyPasswordEmail(client: ITelegramClient, code: string): Promise<void>;
+/**
+ * Resend the code to verify an email to use as 2FA recovery method.
+ */
+export declare function resendPasswordEmail(client: ITelegramClient): Promise<void>;
+/**
+ * Cancel the code that was sent to verify an email to use as 2FA recovery method
+ */
+export declare function cancelPasswordEmail(client: ITelegramClient): Promise<void>;