Class TelegramClient

constructor

• new TelegramClient(opts: TelegramClientOptions): TelegramClient

  Parameters

  • opts: TelegramClientOptions

  Returns TelegramClient

_client

ReadonlyonBotChatJoinRequest

ReadonlyonBotReactionCountUpdate

ReadonlyonBotReactionUpdate

ReadonlyonBotStopped

ReadonlyonBusinessCallbackQuery

ReadonlyonBusinessConnectionUpdate

ReadonlyonBusinessMessageGroup

ReadonlyonCallbackQuery

ReadonlyonChatJoinRequest

ReadonlyonChatMemberUpdate

ReadonlyonChosenInlineResult

ReadonlyonDeleteBusinessMessage

ReadonlyonDeleteMessage

ReadonlyonDeleteStory

ReadonlyonEditBusinessMessage

ReadonlyonEditMessage

ReadonlyonHistoryRead

ReadonlyonInlineCallbackQuery

ReadonlyonInlineQuery

ReadonlyonMessageGroup

ReadonlyonNewBusinessMessage

ReadonlyonNewMessage

ReadonlyonPollUpdate

ReadonlyonPollVote

ReadonlyonPreCheckoutQuery

ReadonlyonRawUpdate

ReadonlyonStoryUpdate

ReadonlyonUpdate

ReadonlyonUserStatusUpdate

ReadonlyonUserTyping

_normalizeInputFile

• _normalizeInputFile(
      input: InputFileLike,
      params: {
          abortSignal?: AbortSignal;
          fileMime?: string;
          fileName?: string;
          fileSize?: number;
          progressCallback?: (uploaded: number, total: number) => void;
      },
  ): Promise<TypeInputFile>

  Normalize a InputFileLike to InputFile, uploading it if needed. Available: ✅ both users and bots

  Parameters

  • input: InputFileLike
  • params: {
        abortSignal?: AbortSignal;
        fileMime?: string;
        fileName?: string;
        fileSize?: number;
        progressCallback?: (uploaded: number, total: number) => void;
    }

  Returns Promise<TypeInputFile>

_normalizeInputMedia

• _normalizeInputMedia(
      media: InputMediaLike,
      params?: {
          abortSignal?: AbortSignal;
          businessConnectionId?: string;
          progressCallback?: (uploaded: number, total: number) => void;
          uploadPeer?: TypeInputPeer;
      },
      uploadMedia?: boolean,
  ): Promise<TypeInputMedia>

  Normalize an InputMediaLike to InputMedia, uploading the file if needed. Available: ✅ both users and bots

  Parameters

  • media: InputMediaLike
  • Optionalparams: {
        abortSignal?: AbortSignal;
        businessConnectionId?: string;
        progressCallback?: (uploaded: number, total: number) => void;
        uploadPeer?: TypeInputPeer;
    }
  • OptionaluploadMedia: boolean

  Returns Promise<TypeInputMedia>

_normalizeInputStarGift

• _normalizeInputStarGift(gift: InputStarGift): Promise<TypeInputSavedStarGift>

  Parameters

  • gift: InputStarGift

  Returns Promise<TypeInputSavedStarGift>

_normalizePrivacyRules

• _normalizePrivacyRules(
      rules: InputPrivacyRule[],
  ): Promise<TypeInputPrivacyRule[]>

  Normalize InputPrivacyRule[] to tl.TypeInputPrivacyRule, resolving the peers if needed. Available: ✅ both users and bots

  Parameters

  • rules: InputPrivacyRule[]

  Returns Promise<TypeInputPrivacyRule[]>

acceptStarGift

• acceptStarGift(
      params: { action: "save" | "hide" | "convert"; gift: InputStarGift },
  ): Promise<boolean>

  Accept, hide or convert a star gift.

  Available: 👤 users only

  Parameters

  • params: { action: "save" | "hide" | "convert"; gift: InputStarGift }

    • action: "save" | "hide" | "convert"

      Action to perform on the gift.

      • save - save the gift to your profile
      • hide - hide the gift from your profile
      • convert - convert the gift to stars (can't be undone)

    • gift: InputStarGift

      Input star gift to accept

  Returns Promise<boolean>

  Whether the action was successful

addChatMembers

• addChatMembers(
      chatId: InputPeerLike,
      users: MaybeArray<InputPeerLike>,
      params: { forwardCount?: number },
  ): Promise<RawMissingInvitee[]>

  Add one or more new members to a group, supergroup or channel.

  Available: 👤 users only

  Parameters

  • chatId: InputPeerLike

    ID of the chat or its username

  • users: MaybeArray<InputPeerLike>

    ID(s) of the user(s) to add

  • params: { forwardCount?: number }

    • OptionalforwardCount?: number

      Number of old messages to be forwarded (0-100). Only applicable to legacy groups, ignored for supergroups and channels

      Default

      100
      Copy

  Returns Promise<RawMissingInvitee[]>

  List of users that were failed to be invited (may be empty)

addContact

• addContact(
      params: {
          firstName: string;
          lastName?: string;
          phone?: string;
          sharePhone?: boolean;
          userId: InputPeerLike;
      },
  ): Promise<User>

  Add an existing Telegram user as a contact Available: 👤 users only

  Parameters

  • params: {
        firstName: string;
        lastName?: string;
        phone?: string;
        sharePhone?: boolean;
        userId: InputPeerLike;
    }

    • firstName: string

      First name of the contact

    • OptionallastName?: string

      Last name of the contact

    • Optionalphone?: string

      Phone number of the contact, if available

    • OptionalsharePhone?: boolean

      Whether to share your own phone number with the newly created contact

      Default

      false
      Copy

    • userId: InputPeerLike

      User ID, username or phone number

  Returns Promise<User>

addStickerToSet

• addStickerToSet(
      setId: InputStickerSet,
      sticker: InputStickerSetItem,
      params?: { progressCallback?: (uploaded: number, total: number) => void },
  ): Promise<StickerSet>

  Add a sticker to a sticker set.

  For bots the sticker set must have been created by this bot.

  Available: ✅ both users and bots

  Parameters

  • setId: InputStickerSet

    Sticker set short name or TL object with input sticker set

  • sticker: InputStickerSetItem

    Sticker to be added

  • Optionalparams: { progressCallback?: (uploaded: number, total: number) => void }

    • OptionalprogressCallback?: (uploaded: number, total: number) => void

      Upload progress callback

  Returns Promise<StickerSet>

  Modfiied sticker set

answerCallbackQuery

• answerCallbackQuery(
      queryId: Long | CallbackQuery,
      params?: {
          alert?: boolean;
          cacheTime?: number;
          text?: string;
          url?: string;
      },
  ): Promise<void>

  Send an answer to a callback query.

  Available: 🤖 bots only

  Parameters

  • queryId: Long | CallbackQuery

    ID of the callback query, or the query itself

  • Optionalparams: { alert?: boolean; cacheTime?: number; text?: string; url?: string }

    Parameters of the answer

    • Optionalalert?: boolean

      Whether to show an alert in the middle of the screen instead of a notification at the top of the screen.

      Default

      false
      Copy

    • OptionalcacheTime?: number

      Maximum amount of time in seconds for which this result can be cached by the client (not server!).

      Default

      0
      Copy

    • Optionaltext?: string

      Text of the notification (0-200 chars).

      If not set, nothing will be displayed

    • Optionalurl?: string

      URL that the client should open.

      If this was a button containing a game, you can provide arbitrary link to your game. Otherwise, you can only use links in the format t.me/your_bot?start=... that open your bot with a deep-link parameter.

  Returns Promise<void>

answerInlineQuery

• answerInlineQuery(
      queryId: Long | InlineQuery,
      results: InputInlineResult[],
      params?: {
          cacheTime?: number;
          gallery?: boolean;
          nextOffset?: string;
          private?: boolean;
          switchPm?: { parameter: string; text: string };
          switchWebview?: { text: string; url: string };
      },
  ): Promise<void>

  Answer an inline query.

  Available: 🤖 bots only

  Parameters

  • queryId: Long | InlineQuery

    Inline query ID

  • results: InputInlineResult[]

    Results of the query

  • Optionalparams: {
        cacheTime?: number;
        gallery?: boolean;
        nextOffset?: string;
        private?: boolean;
        switchPm?: { parameter: string; text: string };
        switchWebview?: { text: string; url: string };
    }

    Additional parameters

    • OptionalcacheTime?: number

      Maximum number of time in seconds that the results of the query may be cached on the server for.

      Default

      300
      Copy

    • Optionalgallery?: boolean

      Whether the results should be displayed as a gallery instead of a vertical list. Only applicable to some media types.

      In some cases changing this may lead to the results not being displayed by the client.

      Default is derived automatically based on result types

    • OptionalnextOffset?: string

      Next pagination offset (up to 64 bytes).

      When user has reached the end of the current results, the client will re-send the inline query with the same text, but with offset set to this value.

      If omitted or empty string is provided, it is assumed that there are no more results.

    • Optionalprivate?: boolean

      Whether the results should only be cached on the server for the user who sent the query.

      Default

      false
      Copy

    • OptionalswitchPm?: { parameter: string; text: string }

      If passed, clients will display a button before any other results, that when clicked switches the user to a private chat with the bot and sends the bot /start ${parameter}.

      An example from the Bot API docs:

      An inline bot that sends YouTube videos can ask the user to connect the bot to their YouTube account to adapt search results accordingly. To do this, it displays a "Connect your YouTube account" button above the results, or even before showing any. The user presses the button, switches to a private chat with the bot and, in doing so, passes a start parameter that instructs the bot to return an oauth link. Once done, the bot can offer a switch_inline button so that the user can easily return to the chat where they wanted to use the bot's inline capabilities

      • parameter: string

        Parameter for /start command

      • text: string

        Text of the button

    • OptionalswitchWebview?: { text: string; url: string }

      If passed, clients will display a button on top of the remaining inline result list with the specified text, that switches the user to the specified bot web app.

      • text: string

        Text of the button

      • url: string

        URL to open

  Returns Promise<void>

answerMedia

• answerMedia(
      message: Message,
      ...params: [
          media: string
          | InputMediaLike,
          params?: CommonSendParams & {
              caption?: InputText;
              invert?: boolean;
              progressCallback?: (uploaded: number, total: number) => void;
              replyMarkup?: ReplyMarkup;
          },
      ],
  ): Promise<Message>

  Send a media to the same chat (and topic, if applicable) as a given message

  Parameters

  • message: Message
  • ...params: [
        media: string
        | InputMediaLike,
        params?: CommonSendParams & {
            caption?: InputText;
            invert?: boolean;
            progressCallback?: (uploaded: number, total: number) => void;
            replyMarkup?: ReplyMarkup;
        },
    ]

  Returns Promise<Message>

answerMediaGroup

• answerMediaGroup(
      message: Message,
      ...params: [
          medias: (string | InputMediaLike)[],
          params?: CommonSendParams & {
              invertMedia?: boolean;
              progressCallback?: (
                  index: number,
                  uploaded: number,
                  total: number,
              ) => void;
          },
      ],
  ): Promise<Message[]>

  Send a media group to the same chat (and topic, if applicable) as a given message

  Parameters

  • message: Message
  • ...params: [
        medias: (string | InputMediaLike)[],
        params?: CommonSendParams & {
            invertMedia?: boolean;
            progressCallback?: (
                index: number,
                uploaded: number,
                total: number,
            ) => void;
        },
    ]

  Returns Promise<Message[]>

answerPreCheckoutQuery

• answerPreCheckoutQuery(
      queryId: Long | PreCheckoutQuery,
      params?: { error?: string },
  ): Promise<void>

  Answer a pre-checkout query.

  Available: 🤖 bots only

  Parameters

  • queryId: Long | PreCheckoutQuery

    Pre-checkout query ID

  • Optionalparams: { error?: string }

    • Optionalerror?: string

      If pre-checkout is rejected, error message to show to the user

  Returns Promise<void>

answerText

• answerText(
      message: Message,
      ...params: [
          text: InputText,
          params?: CommonSendParams & {
              disableWebPreview?: boolean;
              invertMedia?: boolean;
              replyMarkup?: ReplyMarkup;
          },
      ],
  ): Promise<Message>

  Send a text to the same chat (and topic, if applicable) as a given message

  Parameters

  • message: Message
  • ...params: [
        text: InputText,
        params?: CommonSendParams & {
            disableWebPreview?: boolean;
            invertMedia?: boolean;
            replyMarkup?: ReplyMarkup;
        },
    ]

  Returns Promise<Message>

appendTodoList

• appendTodoList(
      params: InputMessageId & {
          items: MaybeArray<InputText>;
          shouldDispatch?: true;
      },
  ): Promise<Message | null>

  Append item(s) to a todo list

  Available: ✅ both users and bots

  Parameters

  • params: InputMessageId & { items: MaybeArray<InputText>; shouldDispatch?: true }

    • items: MaybeArray<InputText>

      Items to append

    • OptionalshouldDispatch?: true

      Whether to dispatch the new message event to the client's update handler.

  Returns Promise<Message | null>

  Service message about the appended todo item(s), if any.

applyBoost

• applyBoost(peerId: InputPeerLike): Promise<void>

  Boost a given channel

  Available: 👤 users only

  Parameters

  • peerId: InputPeerLike

    Peer ID to boost

  Returns Promise<void>

archiveChats

• archiveChats(chats: MaybeArray<InputPeerLike>): Promise<void>

  Archive one or more chats

  Available: 👤 users only

  Parameters

  • chats: MaybeArray<InputPeerLike>

    Chat ID(s), username(s), phone number(s), "me" or "self"

  Returns Promise<void>

banChatMember

• banChatMember(
      params: {
          chatId: InputPeerLike;
          participantId: InputPeerLike;
          shouldDispatch?: true;
          untilDate?: number | Date;
      },
  ): Promise<Message | null>

  Ban a user/channel from a legacy group, a supergroup or a channel. They will not be able to re-join the group on their own, manual administrator's action will be required.

  When banning a channel, the user won't be able to use any of their channels to post until the ban is lifted.

  Available: ✅ both users and bots

  Parameters

  • params: {
        chatId: InputPeerLike;
        participantId: InputPeerLike;
        shouldDispatch?: true;
        untilDate?: number | Date;
    }

    • chatId: InputPeerLike

      Chat ID

    • participantId: InputPeerLike

      ID of the user/channel to ban

    • OptionalshouldDispatch?: true

      Whether to dispatch the returned service message (if any) to the client's update handler.

    • OptionaluntilDate?: number | Date

  Returns Promise<Message | null>

  Service message about removed user, if one was generated.

blockUser

• blockUser(id: InputPeerLike): Promise<void>

  Block a user

  Available: 👤 users only

  Parameters

  • id: InputPeerLike

    User ID, username or phone number

  Returns Promise<void>

buyResaleGift

• buyResaleGift(
      params: {
          recipient: InputPeerLike;
          shouldDispatch?: true;
          slug: string;
          ton?: boolean;
      },
  ): Promise<Message | null>

  Parameters

  • params: { recipient: InputPeerLike; shouldDispatch?: true; slug: string; ton?: boolean }

    • recipient: InputPeerLike

      ID of the user to buy the gift for

    • OptionalshouldDispatch?: true

      Whether to dispatch the new message event to the client's update handler.

    • slug: string

      Slug of the star gift to buy

    • Optionalton?: boolean

      Whether to use TON currency for payment

  Returns Promise<Message | null>

canApplyBoost

• canApplyBoost(): Promise<CanApplyBoostResult>

  Check if the current user can apply boost to some channel

  Available: ✅ both users and bots

  Returns Promise<CanApplyBoostResult>

  • { can: true } if the user can apply boost
    • .replace - Chats that can be replaced with the current one. If the user can apply boost without replacing any chats, this field will be undefined.
    • { can: false } if the user can't apply boost
      • .reason == "no_slots" if the user has no available slots
      • .reason == "need_premium" if the user needs Premium to boost
    • In all cases, slots will contain all the current user's boost slots

cancelPasswordEmail

• cancelPasswordEmail(): Promise<void>

  Cancel the code that was sent to verify an email to use as 2FA recovery method Available: 👤 users only

  Returns Promise<void>

canSendStory

• canSendStory(peerId: InputPeerLike): Promise<CanSendStoryResult>

  Check if the current user can post stories as a given peer

  Available: 👤 users only

  Parameters

  • peerId: InputPeerLike

    Peer ID whose stories to fetch

  Returns Promise<CanSendStoryResult>

  • true if the user can post stories
    • "need_admin" if the user is not an admin in the chat
    • "need_boosts" if the channel doesn't have enough boosts

changeCloudPassword

• changeCloudPassword(
      params: { currentPassword: string; hint?: string; newPassword: string },
  ): Promise<void>

  Change your 2FA password Available: 👤 users only

  Parameters

  • params: { currentPassword: string; hint?: string; newPassword: string }

    • currentPassword: string

      Current password as plaintext

    • Optionalhint?: string

      Hint for the new password

    • newPassword: string

      New password as plaintext

  Returns Promise<void>

checkPassword

• checkPassword(
      options:
          | string
          | {
              abortSignal?: AbortSignal;
              password: string;
              passwordObj?: RawPassword;
          },
  ): Promise<User>

  Check your Two-Step verification password and log in

  Available: 👤 users only

  Parameters

  • options:
        | string
        | {
            abortSignal?: AbortSignal;
            password: string;
            passwordObj?: RawPassword;
        }
    • string
    • { abortSignal?: AbortSignal; password: string; passwordObj?: RawPassword }

      • OptionalabortSignal?: AbortSignal

        Abort signal

      • password: string

        Your Two-Step verification password

      • OptionalpasswordObj?: RawPassword

        Existing response from account.getPassword, if available (to avoid extra API calls)

  Returns Promise<User>

  The authorized user

  Throws

  BadRequestError In case the password is invalid

closeChat

• closeChat(chat: InputPeerLike): Promise<void>

  Inform the library that the user has closed a chat. Un-does the effect of openChat.

  Some library logic depends on this, for example, the library will periodically ping the server to keep the updates flowing.

  Available: ✅ both users and bots

  Parameters

  • chat: InputPeerLike

    Chat to open

  Returns Promise<void>

closePoll

• closePoll(params: InputMessageId & { shouldDispatch?: true }): Promise<Poll>

  Close a poll sent by you.

  Once closed, poll can't be re-opened, and nobody will be able to vote in it Available: ✅ both users and bots

  Parameters

  • params: InputMessageId & { shouldDispatch?: true }

    • OptionalshouldDispatch?: true

      Whether to dispatch the edit message event to the client's update handler.

  Returns Promise<Poll>

closeWebview

• closeWebview(webview: Long | WebviewResult): Promise<void>

  Close a webview previously opened by openWebview method.

  Available: ✅ both users and bots

  Parameters

  • webview: Long | WebviewResult

    Webview result returned by openWebview, or its .queryId

  Returns Promise<void>

commentMedia

• commentMedia(
      message: Message,
      ...params: [
          media: string
          | InputMediaLike,
          params?: CommonSendParams & {
              caption?: InputText;
              invert?: boolean;
              progressCallback?: (uploaded: number, total: number) => void;
              replyMarkup?: ReplyMarkup;
          },
      ],
  ): Promise<Message>

  Send a text comment to a given message.

  If this is a normal message (not a channel post), a simple reply will be sent.

  Available: ✅ both users and bots

  Parameters

  • message: Message
  • ...params: [
        media: string
        | InputMediaLike,
        params?: CommonSendParams & {
            caption?: InputText;
            invert?: boolean;
            progressCallback?: (uploaded: number, total: number) => void;
            replyMarkup?: ReplyMarkup;
        },
    ]

  Returns Promise<Message>

  Throws

  MtArgumentError If this is a channel post which does not have comments section. To check if a post has comments, use Message#replies.hasComments

commentMediaGroup

• commentMediaGroup(
      message: Message,
      ...params: [
          medias: (string | InputMediaLike)[],
          params?: CommonSendParams & {
              invertMedia?: boolean;
              progressCallback?: (
                  index: number,
                  uploaded: number,
                  total: number,
              ) => void;
          },
      ],
  ): Promise<Message[]>

  Send a text comment to a given message.

  If this is a normal message (not a channel post), a simple reply will be sent.

  Available: ✅ both users and bots

  Parameters

  • message: Message
  • ...params: [
        medias: (string | InputMediaLike)[],
        params?: CommonSendParams & {
            invertMedia?: boolean;
            progressCallback?: (
                index: number,
                uploaded: number,
                total: number,
            ) => void;
        },
    ]

  Returns Promise<Message[]>

  Throws

  MtArgumentError If this is a channel post which does not have comments section. To check if a post has comments, use Message#replies.hasComments

commentText

• commentText(
      message: Message,
      ...params: [
          text: InputText,
          params?: CommonSendParams & {
              disableWebPreview?: boolean;
              invertMedia?: boolean;
              replyMarkup?: ReplyMarkup;
          },
      ],
  ): Promise<Message>

  Send a text comment to a given message.

  If this is a normal message (not a channel post), a simple reply will be sent.

  Available: ✅ both users and bots

  Parameters

  • message: Message
  • ...params: [
        text: InputText,
        params?: CommonSendParams & {
            disableWebPreview?: boolean;
            invertMedia?: boolean;
            replyMarkup?: ReplyMarkup;
        },
    ]

  Returns Promise<Message>

  Throws

  MtArgumentError If this is a channel post which does not have comments section. To check if a post has comments, use Message#replies.hasComments

createBusinessChatLink

• createBusinessChatLink(
      text: InputText,
      params?: { title?: string },
  ): Promise<BusinessChatLink>

  Create a new business chat link

  Available: 👤 users only

  Parameters

  • text: InputText

    Text to be inserted into the message input

  • Optionalparams: { title?: string }

    • Optionaltitle?: string

      Custom title for the link

  Returns Promise<BusinessChatLink>

createChannel

• createChannel(params: { description?: string; title: string }): Promise<Chat>

  Create a new broadcast channel

  Available: 👤 users only

  Parameters

  • params: { description?: string; title: string }

    • Optionaldescription?: string

      Channel description

    • title: string

      Channel title

  Returns Promise<Chat>

  Newly created channel

createFolder

• createFolder(
      folder: PartialExcept<RawDialogFilter, "title">,
  ): Promise<RawDialogFilter>

  Create a folder from given parameters

  ID for the folder is optional, if not provided it will be derived automatically.

  Available: 👤 users only

  Parameters

  • folder: PartialExcept<RawDialogFilter, "title">

    Parameters for the folder

  Returns Promise<RawDialogFilter>

  Newly created folder

createForumTopic

• createForumTopic(
      params: {
          chatId: InputPeerLike;
          icon?: number | Long;
          sendAs?: InputPeerLike;
          shouldDispatch?: true;
          title: string;
      },
  ): Promise<Message>

  Create a topic in a forum

  Only admins with manageTopics permission can do this.

  Available: ✅ both users and bots

  Parameters

  • params: {
        chatId: InputPeerLike;
        icon?: number | Long;
        sendAs?: InputPeerLike;
        shouldDispatch?: true;
        title: string;
    }

    • chatId: InputPeerLike

      Chat ID or username

    • Optionalicon?: number | Long

      Icon of the topic.

      Can be a number (color in RGB, see ForumTopic static members for allowed values) or a custom emoji ID.

      Icon color can't be changed after the topic is created.

    • OptionalsendAs?: InputPeerLike

      Send as a specific channel

    • OptionalshouldDispatch?: true

      Whether to dispatch the returned service message (if any) to the client's update handler.

    • title: string

      Topic title

  Returns Promise<Message>

  Service message for the created topic

createGroup

• createGroup(
      params: {
          title: string;
          ttlPeriod?: number;
          users: MaybeArray<InputPeerLike>;
      },
  ): Promise<CreateGroupResult>

  Create a legacy group chat

  If you want to create a supergroup, use createSupergroup instead. Available: 👤 users only

  Parameters

  • params: { title: string; ttlPeriod?: number; users: MaybeArray<InputPeerLike> }

    • title: string

      Group title

    • OptionalttlPeriod?: number

      TTL period (in seconds) for the newly created chat

      Default

      0 (i.e. messages don't expire)
      Copy

    • users: MaybeArray<InputPeerLike>

      User(s) to be invited in the group (ID(s), username(s) or phone number(s)). Due to Telegram limitations, you can't create a legacy group with just yourself.

  Returns Promise<CreateGroupResult>

createInviteLink

• createInviteLink(
      chatId: InputPeerLike,
      params?: {
          expires?: number | Date;
          subscriptionPricing?: RawStarsSubscriptionPricing;
          usageLimit?: number;
          withApproval?: boolean;
      },
  ): Promise<ChatInviteLink>

  Create an additional invite link for the chat.

  You must be an administrator and have appropriate rights.

  Available: ✅ both users and bots

  Parameters

  • chatId: InputPeerLike

    Chat ID

  • Optionalparams: {
        expires?: number | Date;
        subscriptionPricing?: RawStarsSubscriptionPricing;
        usageLimit?: number;
        withApproval?: boolean;
    }

    • Optionalexpires?: number | Date

      Date when this link will expire. If number is passed, UNIX time in ms is expected.

    • OptionalsubscriptionPricing?: RawStarsSubscriptionPricing

      When a pricing plan is passed, this link will become a paid subscription link

      Currently the only allowed .period is 1 month, i.e. 2592000

    • OptionalusageLimit?: number

      Maximum number of users that can be members of this chat at the same time after joining using this link.

      Integer in range [1, 99999] or Infinity

      Default

      Infinity

    • OptionalwithApproval?: boolean

      Whether users to be joined via this link need to be approved by an admin

  Returns Promise<ChatInviteLink>

createStickerSet

• createStickerSet(
      params: {
          adaptive?: boolean;
          owner: InputPeerLike;
          progressCallback?: (idx: number, uploaded: number, total: number) => void;
          shortName: string;
          stickers: InputStickerSetItem[];
          thumb?: InputFileLike;
          title: string;
          type?: StickerType;
      },
  ): Promise<StickerSet>

  Create a new sticker set.

  Available: ✅ both users and bots

  Parameters

  • params: {
        adaptive?: boolean;
        owner: InputPeerLike;
        progressCallback?: (idx: number, uploaded: number, total: number) => void;
        shortName: string;
        stickers: InputStickerSetItem[];
        thumb?: InputFileLike;
        title: string;
        type?: StickerType;
    }

    • Optionaladaptive?: boolean

      Whether to create "adaptive" emoji set.

      Color of the emoji will be changed depending on the text color. Only works for TGS-based emoji stickers

    • owner: InputPeerLike

      Owner of the sticker set (must be user).

      If this pack is created from a user account, can only be "self"

    • OptionalprogressCallback?: (idx: number, uploaded: number, total: number) => void

      Upload progress callback.

    • shortName: string

      Short name of the sticker set. Can only contain English letters, digits and underscores (i.e. must match /^[a-zA-Z0-9_]+$/), and (for bots) must end with by (` is case-insensitive).

    • stickers: InputStickerSetItem[]

      List of stickers to be immediately added into the pack. There must be at least one sticker in this list.

    • Optionalthumb?: InputFileLike

      Thumbnail for the set.

      The file must be either a .png file up to 128kb, having size of exactly 100x100 px, or a .tgs file up to 32kb.

      If not set, Telegram will use the first sticker in the sticker set as the thumbnail

    • title: string

      Title of the sticker set (1-64 chars)

    • Optionaltype?: StickerType

      Type of the stickers in this set.

      Default

      sticker, i.e. regular stickers.

  Returns Promise<StickerSet>

  Newly created sticker set

createSupergroup

• createSupergroup(
      params: {
          description?: string;
          forum?: boolean;
          title: string;
          ttlPeriod?: number;
      },
  ): Promise<Chat>

  Create a new supergroup

  Available: 👤 users only

  Parameters

  • params: { description?: string; forum?: boolean; title: string; ttlPeriod?: number }

    • Optionaldescription?: string

      Supergroup description

    • Optionalforum?: boolean

      Whether to create a forum

    • title: string

      Supergroup title

    • OptionalttlPeriod?: number

      TTL period (in seconds) for the newly created supergroup

      Default

      0 (i.e. messages don't expire)
      Copy

  Returns Promise<Chat>

  Newly created supergroup

deleteBusinessChatLink

• deleteBusinessChatLink(link: string | BusinessChatLink): Promise<void>

  Delete a business chat link

  Available: 👤 users only

  Parameters

  • link: string | BusinessChatLink

    The link to delete

  Returns Promise<void>

deleteChannel

• deleteChannel(chatId: InputPeerLike): Promise<void>

  Delete a channel or a supergroup

  Available: 👤 users only

  Parameters

  • chatId: InputPeerLike

    Chat ID or username

  Returns Promise<void>

deleteChatPhoto

• deleteChatPhoto(chatId: InputPeerLike): Promise<void>

  Delete a chat photo

  You must be an administrator and have the appropriate permissions.

  Available: ✅ both users and bots

  Parameters

  • chatId: InputPeerLike

    Chat ID or username

  Returns Promise<void>

deleteContacts

• deleteContacts(userIds: MaybeArray<InputPeerLike>): Promise<User[]>

  Delete one or more contacts from your Telegram contacts list

  Returns deleted contact's profiles. Does not return profiles of users that were not in your contacts list

  Available: 👤 users only

  Parameters

  • userIds: MaybeArray<InputPeerLike>

    User IDs, usernames or phone numbers

  Returns Promise<User[]>

deleteFolder

• deleteFolder(id: number | RawDialogFilter): Promise<void>

  Delete a folder by its ID

  Available: 👤 users only

  Parameters

  • id: number | RawDialogFilter

    Folder ID or folder itself

  Returns Promise<void>

deleteForumTopicHistory

• deleteForumTopicHistory(
      chat: InputPeerLike,
      topicId: number | ForumTopic,
      params?: { shouldDispatch?: true },
  ): Promise<void>

  Delete a forum topic and all its history

  Available: ✅ both users and bots

  Parameters

  • chat: InputPeerLike

    Chat or user ID, username, phone number, "me" or "self"

  • topicId: number | ForumTopic

    ID of the topic (i.e. its top message ID)

  • Optionalparams: { shouldDispatch?: true }

    • OptionalshouldDispatch?: true

      Whether to dispatch updates that will be generated by this call. Doesn't follow disableNoDispatch

  Returns Promise<void>

deleteGroup

• deleteGroup(chatId: InputPeerLike): Promise<void>

  Delete a legacy group chat for all members

  Available: 👤 users only

  Parameters

  • chatId: InputPeerLike

    Chat ID

  Returns Promise<void>

deleteHistory

• deleteHistory(
      chat: InputPeerLike,
      params?: { maxId?: number; mode: "delete" | "revoke" | "clear" },
  ): Promise<void>

  Delete communication history (for private chats and legacy groups) Available: 👤 users only

  Parameters

  • chat: InputPeerLike
  • Optionalparams: { maxId?: number; mode: "delete" | "revoke" | "clear" }

    • OptionalmaxId?: number

      Maximum ID of message to delete.

      Default

      0, i.e. remove all messages
      Copy

    • mode: "delete" | "revoke" | "clear"

      Deletion mode. Can be:

      • delete: delete messages (only for yourself) AND the dialog itself
      • clear: delete messages (only for yourself), but keep the dialog in the list
      • revoke: delete messages for all users

      Default

      'delete'
      Copy

  Returns Promise<void>

deleteMessages

• deleteMessages(
      messages: Message[],
      params?: DeleteMessagesParams,
  ): Promise<void>

  Delete one or more Message

  Available: ✅ both users and bots

  Parameters

  • messages: Message[]

    Message(s) to delete

  • Optionalparams: DeleteMessagesParams

  Returns Promise<void>