@overpod/mcp-telegram 1.25.0 → 1.26.0

package/dist/telegram-client.js

@@ -134,6 +134,129 @@ export function reactionToEmoji(reaction) {
         return "⭐";
     return null;
 }
+function absValue(v) {
+    return { current: v?.current ?? 0, previous: v?.previous ?? 0 };
+}
+function compactGraph(g) {
+    if (g instanceof Api.StatsGraphAsync)
+        return { type: "async", token: g.token };
+    if (g instanceof Api.StatsGraphError)
+        return { type: "error", error: g.error };
+    if (g instanceof Api.StatsGraph) {
+        let parsed = g.json?.data;
+        if (typeof parsed === "string") {
+            try {
+                parsed = JSON.parse(parsed);
+            }
+            catch {
+                // leave raw string
+            }
+        }
+        return { type: "data", data: parsed, zoomToken: g.zoomToken };
+    }
+    const any = g;
+    if (typeof any.token === "string")
+        return { type: "async", token: any.token };
+    if (typeof any.error === "string")
+        return { type: "error", error: any.error };
+    return { type: "data", data: any.json?.data, zoomToken: any.zoomToken };
+}
+export function summarizeMegagroupStats(stats, includeGraphs) {
+    const summary = {
+        period: {
+            minDate: stats.period?.minDate ?? 0,
+            maxDate: stats.period?.maxDate ?? 0,
+        },
+        members: absValue(stats.members),
+        messages: absValue(stats.messages),
+        viewers: absValue(stats.viewers),
+        posters: absValue(stats.posters),
+        topPosters: (stats.topPosters ?? []).map((p) => ({
+            userId: p.userId?.toString() ?? "",
+            messages: p.messages,
+            avgChars: p.avgChars,
+        })),
+        topAdmins: (stats.topAdmins ?? []).map((a) => ({
+            userId: a.userId?.toString() ?? "",
+            deleted: a.deleted,
+            kicked: a.kicked,
+            banned: a.banned,
+        })),
+        topInviters: (stats.topInviters ?? []).map((i) => ({
+            userId: i.userId?.toString() ?? "",
+            invitations: i.invitations,
+        })),
+    };
+    if (includeGraphs) {
+        summary.graphs = {
+            growth: compactGraph(stats.growthGraph),
+            members: compactGraph(stats.membersGraph),
+            newMembersBySource: compactGraph(stats.newMembersBySourceGraph),
+            languages: compactGraph(stats.languagesGraph),
+            messages: compactGraph(stats.messagesGraph),
+            actions: compactGraph(stats.actionsGraph),
+            topHours: compactGraph(stats.topHoursGraph),
+            weekdays: compactGraph(stats.weekdaysGraph),
+        };
+    }
+    return summary;
+}
+export function summarizeBroadcastStats(stats, includeGraphs) {
+    const enabled = stats.enabledNotifications;
+    const part = enabled?.part ?? 0;
+    const total = enabled?.total ?? 0;
+    const percent = total > 0 ? (part / total) * 100 : 0;
+    const summary = {
+        period: {
+            minDate: stats.period?.minDate ?? 0,
+            maxDate: stats.period?.maxDate ?? 0,
+        },
+        followers: absValue(stats.followers),
+        viewsPerPost: absValue(stats.viewsPerPost),
+        sharesPerPost: absValue(stats.sharesPerPost),
+        reactionsPerPost: absValue(stats.reactionsPerPost),
+        viewsPerStory: absValue(stats.viewsPerStory),
+        sharesPerStory: absValue(stats.sharesPerStory),
+        reactionsPerStory: absValue(stats.reactionsPerStory),
+        enabledNotifications: { part, total, percent },
+        recentPostsInteractions: (stats.recentPostsInteractions ?? []).map((p) => {
+            if (p instanceof Api.PostInteractionCountersStory) {
+                return {
+                    kind: "story",
+                    storyId: p.storyId,
+                    views: p.views,
+                    forwards: p.forwards,
+                    reactions: p.reactions,
+                };
+            }
+            const m = p;
+            return {
+                kind: "message",
+                msgId: m.msgId,
+                views: m.views,
+                forwards: m.forwards,
+                reactions: m.reactions,
+            };
+        }),
+    };
+    if (includeGraphs) {
+        summary.graphs = {
+            growth: compactGraph(stats.growthGraph),
+            followers: compactGraph(stats.followersGraph),
+            mute: compactGraph(stats.muteGraph),
+            topHours: compactGraph(stats.topHoursGraph),
+            interactions: compactGraph(stats.interactionsGraph),
+            ivInteractions: compactGraph(stats.ivInteractionsGraph),
+            viewsBySource: compactGraph(stats.viewsBySourceGraph),
+            newFollowersBySource: compactGraph(stats.newFollowersBySourceGraph),
+            languages: compactGraph(stats.languagesGraph),
+            reactionsByEmotion: compactGraph(stats.reactionsByEmotionGraph),
+            storyInteractions: compactGraph(stats.storyInteractionsGraph),
+            storyReactionsByEmotion: compactGraph(stats.storyReactionsByEmotionGraph),
+        };
+    }
+    return summary;
+}
 const BANNED_RIGHT_FLAGS = [
     "sendMessages",
     "sendMedia",
@@ -175,6 +298,621 @@ export function mergeBannedRights(current, permissions) {
     }
     return result;
 }
+export function describeKeyboardButton(button, row, col) {
+    const base = {
+        row,
+        col,
+        type: button.className,
+        label: "text" in button && typeof button.text === "string" ? button.text : "",
+    };
+    if (button instanceof Api.KeyboardButtonCallback) {
+        base.data = Buffer.from(button.data).toString("base64");
+        if (button.requiresPassword)
+            base.requiresPassword = true;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonUrl) {
+        base.url = button.url;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonUrlAuth) {
+        base.url = button.url;
+        base.buttonId = button.buttonId;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonSwitchInline) {
+        base.switchQuery = button.query;
+        base.samePeer = Boolean(button.samePeer);
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonWebView || button instanceof Api.KeyboardButtonSimpleWebView) {
+        base.url = button.url;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonUserProfile) {
+        base.userId = button.userId?.toString();
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonRequestPoll) {
+        if (button.quiz)
+            base.quiz = true;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonRequestPeer) {
+        base.buttonId = button.buttonId;
+        return base;
+    }
+    if (button instanceof Api.KeyboardButtonCopy) {
+        base.copyText = button.copyText;
+        return base;
+    }
+    return base;
+}
+export function peerToCompact(peer) {
+    if (!peer)
+        return undefined;
+    if (peer instanceof Api.PeerUser)
+        return { kind: "user", id: peer.userId.toString() };
+    if (peer instanceof Api.PeerChat)
+        return { kind: "chat", id: peer.chatId.toString() };
+    if (peer instanceof Api.PeerChannel)
+        return { kind: "channel", id: peer.channelId.toString() };
+    return undefined;
+}
+function summarizeMessageForUpdates(msg) {
+    if (msg instanceof Api.MessageEmpty)
+        return null;
+    const peer = peerToCompact(msg.peerId);
+    if (!peer)
+        return null;
+    const fromId = peerToCompact(msg.fromId);
+    const date = msg.date ?? 0;
+    if (msg instanceof Api.Message) {
+        return { id: msg.id, peer, fromId, date, text: msg.message ?? "", isService: false };
+    }
+    if (msg instanceof Api.MessageService) {
+        return {
+            id: msg.id,
+            peer,
+            fromId,
+            date,
+            text: `[${msg.action?.className ?? "service"}]`,
+            isService: true,
+        };
+    }
+    return null;
+}
+function collectDeletedMessageIds(updates) {
+    const out = [];
+    for (const u of updates) {
+        if (u instanceof Api.UpdateDeleteMessages) {
+            out.push({ messageIds: u.messages });
+        }
+        else if (u instanceof Api.UpdateDeleteChannelMessages) {
+            out.push({
+                peer: { kind: "channel", id: u.channelId.toString() },
+                messageIds: u.messages,
+            });
+        }
+    }
+    return out;
+}
+export function summarizeUpdatesDifference(diff, cursor) {
+    if (diff instanceof Api.updates.DifferenceEmpty) {
+        return {
+            state: { pts: cursor.pts, qts: cursor.qts, date: diff.date, seq: diff.seq },
+            isFinal: true,
+            newMessages: [],
+            deletedMessageIds: [],
+            otherUpdates: [],
+        };
+    }
+    if (diff instanceof Api.updates.DifferenceTooLong) {
+        return {
+            state: { pts: diff.pts, qts: cursor.qts, date: cursor.date, seq: 0 },
+            isFinal: true,
+            newMessages: [],
+            deletedMessageIds: [],
+            otherUpdates: [],
+            fallback: {
+                kind: "tooLong",
+                suggestedAction: "gap too large — call telegram-read-messages per chat or telegram-get-state to resync",
+            },
+        };
+    }
+    const isFinal = diff instanceof Api.updates.Difference;
+    const state = isFinal
+        ? diff.state
+        : diff.intermediateState;
+    const newMessages = (diff.newMessages ?? [])
+        .map(summarizeMessageForUpdates)
+        .filter((m) => m !== null);
+    const otherUpdates = diff.otherUpdates ?? [];
+    return {
+        state: {
+            pts: state.pts,
+            qts: state.qts,
+            date: state.date,
+            seq: state.seq,
+            unreadCount: state.unreadCount,
+        },
+        isFinal,
+        newMessages,
+        deletedMessageIds: collectDeletedMessageIds(otherUpdates),
+        otherUpdates: otherUpdates.map((u) => ({ type: u.className })),
+    };
+}
+export function summarizeChannelDifference(diff, channelId, fallbackPts) {
+    if (diff instanceof Api.updates.ChannelDifferenceEmpty) {
+        return {
+            channelId,
+            pts: diff.pts,
+            isFinal: Boolean(diff.final),
+            timeout: diff.timeout,
+            newMessages: [],
+            otherUpdates: [],
+        };
+    }
+    if (diff instanceof Api.updates.ChannelDifferenceTooLong) {
+        const freshPts = diff.dialog instanceof Api.Dialog ? (diff.dialog.pts ?? fallbackPts) : fallbackPts;
+        return {
+            channelId,
+            pts: freshPts,
+            isFinal: Boolean(diff.final),
+            timeout: diff.timeout,
+            newMessages: (diff.messages ?? [])
+                .map(summarizeMessageForUpdates)
+                .filter((m) => m !== null),
+            otherUpdates: [],
+            fallback: {
+                kind: "tooLong",
+                suggestedAction: "channel gap too large — dialog snapshot returned; call telegram-read-messages for full history",
+            },
+        };
+    }
+    if (diff instanceof Api.updates.ChannelDifference) {
+        return {
+            channelId,
+            pts: diff.pts,
+            isFinal: Boolean(diff.final),
+            timeout: diff.timeout,
+            newMessages: (diff.newMessages ?? [])
+                .map(summarizeMessageForUpdates)
+                .filter((m) => m !== null),
+            otherUpdates: (diff.otherUpdates ?? []).map((u) => ({ type: u.className })),
+        };
+    }
+    return {
+        channelId,
+        pts: fallbackPts,
+        isFinal: false,
+        newMessages: [],
+        otherUpdates: [],
+    };
+}
+export function summarizeMyBoost(boost) {
+    const b = boost;
+    return {
+        slot: b.slot,
+        peer: peerToCompact(b.peer),
+        date: b.date,
+        expires: b.expires,
+        cooldownUntilDate: b.cooldownUntilDate,
+    };
+}
+export function summarizeMyBoosts(result) {
+    const boosts = result.myBoosts ?? [];
+    return {
+        count: boosts.length,
+        myBoosts: boosts.map(summarizeMyBoost),
+    };
+}
+export function summarizePrepaidGiveaway(g) {
+    if (g instanceof Api.PrepaidStarsGiveaway) {
+        return {
+            kind: "stars",
+            id: g.id.toString(),
+            quantity: g.quantity,
+            date: g.date,
+            stars: g.stars.toString(),
+            boosts: g.boosts,
+        };
+    }
+    const p = g;
+    return {
+        kind: "premium",
+        id: p.id.toString(),
+        quantity: p.quantity,
+        date: p.date,
+        months: p.months,
+    };
+}
+export function summarizeBoostsStatus(result) {
+    const r = result;
+    const out = {
+        level: r.level,
+        boosts: r.boosts,
+        currentLevelBoosts: r.currentLevelBoosts,
+        nextLevelBoosts: r.nextLevelBoosts,
+        giftBoosts: r.giftBoosts,
+        boostUrl: r.boostUrl,
+        myBoost: r.myBoost,
+        myBoostSlots: r.myBoostSlots,
+    };
+    if (r.premiumAudience) {
+        out.premiumAudience = { part: r.premiumAudience.part, total: r.premiumAudience.total };
+    }
+    if (r.prepaidGiveaways && r.prepaidGiveaways.length > 0) {
+        out.prepaidGiveaways = r.prepaidGiveaways.map(summarizePrepaidGiveaway);
+    }
+    return out;
+}
+export function summarizeBoost(boost) {
+    const b = boost;
+    return {
+        id: b.id,
+        userId: b.userId?.toString(),
+        date: b.date,
+        expires: b.expires,
+        gift: b.gift,
+        giveaway: b.giveaway,
+        unclaimed: b.unclaimed,
+        giveawayMsgId: b.giveawayMsgId,
+        usedGiftSlug: b.usedGiftSlug,
+        multiplier: b.multiplier,
+        stars: b.stars?.toString(),
+    };
+}
+export function summarizeBoostsList(result) {
+    const r = result;
+    return {
+        count: r.count,
+        boosts: (r.boosts ?? []).map(summarizeBoost),
+        nextOffset: r.nextOffset,
+    };
+}
+export function summarizeBusinessChatLink(link) {
+    const l = link;
+    return {
+        link: l.link,
+        message: l.message,
+        title: l.title,
+        views: l.views,
+        entityCount: l.entities?.length ?? 0,
+    };
+}
+export function summarizeBusinessChatLinks(result) {
+    const r = result;
+    const links = r.links ?? [];
+    return {
+        count: links.length,
+        links: links.map(summarizeBusinessChatLink),
+    };
+}
+export function summarizeGroupCallInfo(call) {
+    if (call instanceof Api.GroupCallDiscarded) {
+        return {
+            kind: "discarded",
+            id: call.id.toString(),
+            accessHash: call.accessHash.toString(),
+            duration: call.duration,
+        };
+    }
+    const c = call;
+    return {
+        kind: "active",
+        id: c.id.toString(),
+        accessHash: c.accessHash.toString(),
+        participantsCount: c.participantsCount,
+        title: c.title,
+        scheduleDate: c.scheduleDate,
+        recordStartDate: c.recordStartDate,
+        streamDcId: c.streamDcId,
+        unmutedVideoCount: c.unmutedVideoCount,
+        unmutedVideoLimit: c.unmutedVideoLimit,
+        version: c.version,
+        joinMuted: c.joinMuted,
+        canChangeJoinMuted: c.canChangeJoinMuted,
+        joinDateAsc: c.joinDateAsc,
+        scheduleStartSubscribed: c.scheduleStartSubscribed,
+        canStartVideo: c.canStartVideo,
+        recordVideoActive: c.recordVideoActive,
+        rtmpStream: c.rtmpStream,
+        listenersHidden: c.listenersHidden,
+    };
+}
+export function summarizeGroupCallParticipant(p) {
+    const gp = p;
+    return {
+        peer: peerToCompact(gp.peer),
+        date: gp.date,
+        activeDate: gp.activeDate,
+        source: gp.source,
+        volume: gp.volume,
+        muted: gp.muted,
+        left: gp.left,
+        canSelfUnmute: gp.canSelfUnmute,
+        justJoined: gp.justJoined,
+        self: gp.self,
+        mutedByYou: gp.mutedByYou,
+        volumeByAdmin: gp.volumeByAdmin,
+        videoJoined: gp.videoJoined,
+        about: gp.about,
+        raiseHandRating: gp.raiseHandRating?.toString(),
+        hasVideo: gp.video ? true : undefined,
+        hasPresentation: gp.presentation ? true : undefined,
+    };
+}
+export function summarizeGroupCall(result) {
+    const r = result;
+    return {
+        call: summarizeGroupCallInfo(r.call),
+        participants: (r.participants ?? []).map(summarizeGroupCallParticipant),
+        participantsNextOffset: r.participantsNextOffset || undefined,
+    };
+}
+export function summarizeGroupCallParticipants(result) {
+    const r = result;
+    return {
+        count: r.count,
+        participants: (r.participants ?? []).map(summarizeGroupCallParticipant),
+        nextOffset: r.nextOffset || undefined,
+        version: r.version,
+    };
+}
+export function summarizeStarsAmount(amount) {
+    const a = amount;
+    return { amount: a.amount.toString(), nanos: a.nanos };
+}
+export function summarizeStarsTransactionPeer(peer) {
+    if (peer instanceof Api.StarsTransactionPeerAppStore)
+        return { kind: "appStore" };
+    if (peer instanceof Api.StarsTransactionPeerPlayMarket)
+        return { kind: "playMarket" };
+    if (peer instanceof Api.StarsTransactionPeerPremiumBot)
+        return { kind: "premiumBot" };
+    if (peer instanceof Api.StarsTransactionPeerFragment)
+        return { kind: "fragment" };
+    if (peer instanceof Api.StarsTransactionPeerAds)
+        return { kind: "ads" };
+    if (peer instanceof Api.StarsTransactionPeerAPI)
+        return { kind: "api" };
+    if (peer instanceof Api.StarsTransactionPeer)
+        return { kind: "peer", peer: peerToCompact(peer.peer) };
+    return { kind: "unsupported" };
+}
+export function summarizeStarsTransaction(tx) {
+    const t = tx;
+    return {
+        id: t.id,
+        stars: summarizeStarsAmount(t.stars),
+        date: t.date,
+        peer: summarizeStarsTransactionPeer(t.peer),
+        refund: t.refund,
+        pending: t.pending,
+        failed: t.failed,
+        gift: t.gift,
+        reaction: t.reaction,
+        title: t.title,
+        description: t.description,
+        msgId: t.msgId,
+        subscriptionPeriod: t.subscriptionPeriod,
+        giveawayPostId: t.giveawayPostId,
+        transactionDate: t.transactionDate,
+        transactionUrl: t.transactionUrl,
+    };
+}
+export function summarizeStarsSubscription(sub) {
+    const s = sub;
+    const pricing = s.pricing;
+    return {
+        id: s.id,
+        peer: peerToCompact(s.peer),
+        untilDate: s.untilDate,
+        pricing: { period: pricing.period, amount: pricing.amount.toString() },
+        canceled: s.canceled,
+        canRefulfill: s.canRefulfill,
+        missingBalance: s.missingBalance,
+        botCanceled: s.botCanceled,
+        chatInviteHash: s.chatInviteHash,
+        title: s.title,
+        invoiceSlug: s.invoiceSlug,
+    };
+}
+export function summarizeQuickReply(reply) {
+    const r = reply;
+    return {
+        shortcutId: r.shortcutId,
+        shortcut: r.shortcut,
+        topMessage: r.topMessage,
+        count: r.count,
+    };
+}
+export function summarizeQuickReplies(result) {
+    if (result instanceof Api.messages.QuickRepliesNotModified) {
+        return { notModified: true };
+    }
+    const r = result;
+    return { quickReplies: r.quickReplies.map(summarizeQuickReply) };
+}
+export function summarizeQuickReplyMessage(msg) {
+    if (msg instanceof Api.MessageEmpty)
+        return null;
+    const base = msg;
+    const fromId = peerToCompact(base.fromId);
+    const replyHeader = base.replyTo;
+    const replyToMsgId = replyHeader instanceof Api.MessageReplyHeader ? replyHeader.replyToMsgId : undefined;
+    if (msg instanceof Api.Message) {
+        return {
+            id: msg.id,
+            date: msg.date,
+            text: msg.message ?? "",
+            isService: false,
+            fromId,
+            replyToMsgId,
+        };
+    }
+    if (msg instanceof Api.MessageService) {
+        return {
+            id: msg.id,
+            date: msg.date,
+            text: `[${msg.action?.className ?? "service"}]`,
+            isService: true,
+            fromId,
+        };
+    }
+    return null;
+}
+export function summarizeQuickReplyMessages(result) {
+    if (result instanceof Api.messages.MessagesNotModified) {
+        return { notModified: true, count: result.count };
+    }
+    const rawMessages = result
+        .messages;
+    const messages = rawMessages.map(summarizeQuickReplyMessage).filter((m) => m !== null);
+    const count = result instanceof Api.messages.Messages
+        ? messages.length
+        : result.count;
+    return { count, messages };
+}
+export function summarizeStarsStatus(result) {
+    const r = result;
+    const out = {
+        balance: summarizeStarsAmount(r.balance),
+        subscriptionsNextOffset: r.subscriptionsNextOffset || undefined,
+        subscriptionsMissingBalance: r.subscriptionsMissingBalance?.toString(),
+        nextOffset: r.nextOffset || undefined,
+    };
+    if (r.subscriptions && r.subscriptions.length > 0) {
+        out.subscriptions = r.subscriptions.map(summarizeStarsSubscription);
+    }
+    if (r.history && r.history.length > 0) {
+        out.history = r.history.map(summarizeStarsTransaction);
+    }
+    return out;
+}
+export function summarizeStoryItem(item) {
+    if (item instanceof Api.StoryItemDeleted) {
+        return { id: item.id, kind: "deleted" };
+    }
+    if (item instanceof Api.StoryItemSkipped) {
+        return {
+            id: item.id,
+            kind: "skipped",
+            date: item.date,
+            expireDate: item.expireDate,
+            closeFriends: item.closeFriends,
+        };
+    }
+    const story = item;
+    return {
+        id: story.id,
+        kind: "active",
+        date: story.date,
+        expireDate: story.expireDate,
+        caption: story.caption,
+        mediaType: story.media?.className,
+        pinned: story.pinned,
+        public: story.public,
+        closeFriends: story.closeFriends,
+        edited: story.edited,
+        noforwards: story.noforwards,
+        fromId: peerToCompact(story.fromId),
+        viewsCount: story.views?.viewsCount,
+        reactionsCount: story.views?.reactionsCount,
+    };
+}
+export function summarizePeerStories(ps) {
+    const peer = peerToCompact(ps.peer);
+    if (!peer)
+        return null;
+    return {
+        peer,
+        maxReadId: ps.maxReadId,
+        stories: (ps.stories ?? []).map(summarizeStoryItem),
+    };
+}
+export function summarizeStoriesById(result) {
+    return {
+        count: result.count,
+        stories: (result.stories ?? []).map(summarizeStoryItem),
+        pinnedToTop: result.pinnedToTop,
+    };
+}
+export function summarizeStoryView(view) {
+    if (view instanceof Api.StoryViewPublicForward) {
+        const msg = view.message;
+        const messageId = msg instanceof Api.MessageEmpty ? undefined : msg?.id;
+        const peer = msg instanceof Api.MessageEmpty
+            ? undefined
+            : peerToCompact(msg?.peerId);
+        return {
+            kind: "publicForward",
+            messageId,
+            peer,
+            blocked: view.blocked,
+            blockedMyStoriesFrom: view.blockedMyStoriesFrom,
+        };
+    }
+    if (view instanceof Api.StoryViewPublicRepost) {
+        const story = view.story;
+        return {
+            kind: "publicRepost",
+            peer: peerToCompact(view.peerId),
+            storyId: story?.id,
+            blocked: view.blocked,
+            blockedMyStoriesFrom: view.blockedMyStoriesFrom,
+        };
+    }
+    const v = view;
+    return {
+        kind: "user",
+        userId: v.userId.toString(),
+        date: v.date,
+        reaction: v.reaction ? reactionToEmoji(v.reaction) : undefined,
+        blocked: v.blocked,
+        blockedMyStoriesFrom: v.blockedMyStoriesFrom,
+    };
+}
+export function summarizeStoryViewsList(result) {
+    const list = result;
+    return {
+        count: list.count,
+        viewsCount: list.viewsCount,
+        forwardsCount: list.forwardsCount,
+        reactionsCount: list.reactionsCount,
+        views: (list.views ?? []).map(summarizeStoryView),
+        nextOffset: list.nextOffset,
+    };
+}
+export function summarizeAllStories(result) {
+    const stealthMode = result.stealthMode
+        ? {
+            activeUntilDate: result.stealthMode.activeUntilDate,
+            cooldownUntilDate: result.stealthMode.cooldownUntilDate,
+        }
+        : undefined;
+    if (result instanceof Api.stories.AllStoriesNotModified) {
+        return {
+            modified: false,
+            state: result.state,
+            peerStories: [],
+            stealthMode,
+        };
+    }
+    const all = result;
+    const peerStories = (all.peerStories ?? [])
+        .map(summarizePeerStories)
+        .filter((p) => p !== null);
+    return {
+        modified: true,
+        state: all.state,
+        hasMore: all.hasMore,
+        count: all.count,
+        peerStories,
+        stealthMode,
+    };
+}
 export class TelegramService {
     client = null;
     apiId;
@@ -950,6 +1688,9 @@ export class TelegramService {
      */
     // biome-ignore lint: GramJS has no proper entity union type
     async resolvePeer(chatId) {
+        // Normalize '@me' — GramJS only intercepts the plain 'me' string as InputPeerSelf
+        if (chatId === "@me")
+            return "me";
         // Numeric IDs and @usernames work directly
         if (/^-?\d+$/.test(chatId) || chatId.startsWith("@"))
             return chatId;
@@ -2151,6 +2892,375 @@ export class TelegramService {
             await this.client?.invoke(new Api.channels.ToggleSlowMode({ channel: entity, seconds }));
         }, `setSlowMode ${chatId}`);
     }
+    async toggleChannelSignatures(chatId, enabled) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Channel signatures are only available for broadcast channels (not groups or supergroups)");
+            }
+            if (entity.megagroup) {
+                throw new Error("Channel signatures are only available for broadcast channels, not supergroups");
+            }
+            await this.client?.invoke(new Api.channels.ToggleSignatures({ channel: entity, signaturesEnabled: enabled }));
+        }, `toggleChannelSignatures ${chatId}`);
+    }
+    async toggleAntiSpam(chatId, enabled) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Aggressive anti-spam is only available for supergroups");
+            }
+            if (!entity.megagroup) {
+                throw new Error("Aggressive anti-spam is only available for supergroups, not broadcast channels");
+            }
+            await this.client?.invoke(new Api.channels.ToggleAntiSpam({ channel: entity, enabled }));
+        }, `toggleAntiSpam ${chatId}`);
+    }
+    async toggleForumMode(chatId, enabled) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Forum mode is only available for supergroups");
+            }
+            if (!entity.megagroup) {
+                throw new Error("Forum mode is only available for supergroups, not broadcast channels");
+            }
+            await this.client?.invoke(new Api.channels.ToggleForum({ channel: entity, enabled }));
+        }, `toggleForumMode ${chatId}`);
+    }
+    async togglePrehistoryHidden(chatId, hidden) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Prehistory visibility is only available for supergroups");
+            }
+            if (!entity.megagroup) {
+                throw new Error("Prehistory visibility is only available for supergroups, not broadcast channels");
+            }
+            await this.client?.invoke(new Api.channels.TogglePreHistoryHidden({ channel: entity, enabled: hidden }));
+        }, `togglePrehistoryHidden ${chatId}`);
+    }
+    async setChatAvailableReactions(chatId, reactions) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel) && !(entity instanceof Api.Chat)) {
+                throw new Error("Chat reactions can only be configured for groups, supergroups, and channels");
+            }
+            let availableReactions;
+            if (reactions.type === "all") {
+                availableReactions = new Api.ChatReactionsAll({ allowCustom: reactions.allowCustom });
+            }
+            else if (reactions.type === "none") {
+                availableReactions = new Api.ChatReactionsNone();
+            }
+            else {
+                if (reactions.emoji.length === 0) {
+                    throw new Error('reactions.emoji must be non-empty when type is "some" (use type:"none" to disable)');
+                }
+                availableReactions = new Api.ChatReactionsSome({
+                    reactions: reactions.emoji.map((emoticon) => new Api.ReactionEmoji({ emoticon })),
+                });
+            }
+            await this.client?.invoke(new Api.messages.SetChatAvailableReactions({ peer: entity, availableReactions }));
+        }, `setChatAvailableReactions ${chatId}`);
+    }
+    async approveChatJoinRequest(chatId, userId, approved) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Join request approval is only supported for supergroups and channels, not basic groups");
+            }
+            const user = await this.client?.getEntity(userId);
+            if (!(user instanceof Api.User)) {
+                throw new Error("Target is not a user");
+            }
+            const inputUser = new Api.InputUser({ userId: user.id, accessHash: user.accessHash ?? bigInt.zero });
+            await this.client?.invoke(new Api.messages.HideChatJoinRequest({ peer: entity, userId: inputUser, approved }));
+        }, `approveChatJoinRequest ${chatId}/${userId}`);
+    }
+    async getInlineBotResults(bot, chatId, query, offset) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const peer = await this.resolveChat(chatId);
+            const botEntity = await this.client?.getEntity(bot);
+            if (!(botEntity instanceof Api.User)) {
+                throw new Error(`'${bot}' is not a user/bot`);
+            }
+            if (!botEntity.bot) {
+                throw new Error(`'${bot}' is not a bot (inline queries require a bot account)`);
+            }
+            const inputBot = new Api.InputUser({
+                userId: botEntity.id,
+                accessHash: botEntity.accessHash ?? bigInt.zero,
+            });
+            const result = await this.client?.invoke(new Api.messages.GetInlineBotResults({
+                bot: inputBot,
+                peer,
+                query,
+                offset: offset ?? "",
+            }));
+            if (!result)
+                throw new Error("No inline bot results returned");
+            return {
+                queryId: result.queryId.toString(),
+                nextOffset: result.nextOffset,
+                cacheTime: result.cacheTime,
+                gallery: result.gallery === true,
+                results: result.results.map((r) => {
+                    if (r instanceof Api.BotInlineResult) {
+                        return { id: r.id, type: r.type, title: r.title, description: r.description, url: r.url };
+                    }
+                    const mr = r;
+                    return { id: mr.id, type: mr.type, title: mr.title, description: mr.description };
+                }),
+            };
+        }, `getInlineBotResults via ${bot}`);
+    }
+    async sendInlineBotResult(chatId, queryId, resultId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const peer = await this.resolveChat(chatId);
+            const randomId = bigInt(Math.floor(Math.random() * 1e15));
+            const replyTo = options?.replyTo ? new Api.InputReplyToMessage({ replyToMsgId: options.replyTo }) : undefined;
+            const result = await this.client?.invoke(new Api.messages.SendInlineBotResult({
+                peer,
+                queryId: bigInt(queryId),
+                id: resultId,
+                randomId,
+                ...(replyTo ? { replyTo } : {}),
+                ...(options?.silent ? { silent: true } : {}),
+                ...(options?.hideVia ? { hideVia: true } : {}),
+                ...(options?.clearDraft ? { clearDraft: true } : {}),
+            }));
+            if (!result)
+                throw new Error("No response from SendInlineBotResult");
+            if (result instanceof Api.Updates || result instanceof Api.UpdatesCombined) {
+                for (const update of result.updates) {
+                    if (update instanceof Api.UpdateMessageID && update.randomId?.equals(randomId)) {
+                        return { messageId: update.id };
+                    }
+                }
+            }
+            if (result instanceof Api.UpdateShortSentMessage) {
+                return { messageId: result.id };
+            }
+            return { messageId: 0 };
+        }, `sendInlineBotResult ${resultId} to ${chatId}`);
+    }
+    async pressButton(chatId, messageId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            let data;
+            if (options.buttonIndex) {
+                const { row, column } = options.buttonIndex;
+                const messages = await this.client?.getMessages(entity, { ids: [messageId] });
+                const msg = messages?.[0];
+                if (!msg)
+                    throw new Error(`Message ${messageId} not found in ${chatId}`);
+                const markup = msg.replyMarkup;
+                if (!markup)
+                    throw new Error(`Message ${messageId} has no reply markup`);
+                if (!(markup instanceof Api.ReplyInlineMarkup)) {
+                    throw new Error(`Message ${messageId} reply markup is ${markup.className} (only ReplyInlineMarkup has callable buttons)`);
+                }
+                const rowEntry = markup.rows[row];
+                if (!rowEntry)
+                    throw new Error(`Row ${row} out of bounds (message has ${markup.rows.length} rows)`);
+                const button = rowEntry.buttons[column];
+                if (!button) {
+                    throw new Error(`Column ${column} out of bounds in row ${row} (row has ${rowEntry.buttons.length} buttons)`);
+                }
+                if (!(button instanceof Api.KeyboardButtonCallback)) {
+                    throw new Error(`Button at (${row},${column}) is ${button.className}, not callable — use the appropriate tool for URL/switch-inline/game buttons`);
+                }
+                if (button.requiresPassword) {
+                    throw new Error(`Button at (${row},${column}) requires 2FA password confirmation — not supported by telegram-press-button`);
+                }
+                data = Buffer.from(button.data);
+            }
+            else if (options.data !== undefined) {
+                data = Buffer.from(options.data, "base64");
+            }
+            else {
+                throw new Error("Either buttonIndex or data must be provided");
+            }
+            const answer = await this.client?.invoke(new Api.messages.GetBotCallbackAnswer({
+                peer: entity,
+                msgId: messageId,
+                data,
+            }));
+            if (!answer)
+                throw new Error("No callback answer returned");
+            return {
+                alert: answer.alert,
+                hasUrl: answer.hasUrl,
+                nativeUi: answer.nativeUi,
+                message: answer.message,
+                url: answer.url,
+                cacheTime: answer.cacheTime,
+            };
+        }, `pressButton ${chatId}/${messageId}`);
+    }
+    async getMessageButtons(chatId, messageId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            const messages = await this.client?.getMessages(entity, { ids: [messageId] });
+            const msg = messages?.[0];
+            if (!msg)
+                throw new Error(`Message ${messageId} not found in ${chatId}`);
+            const markup = msg.replyMarkup;
+            if (!markup) {
+                return { markupType: "none", buttons: [] };
+            }
+            if (!(markup instanceof Api.ReplyInlineMarkup) && !(markup instanceof Api.ReplyKeyboardMarkup)) {
+                return { markupType: markup.className, buttons: [] };
+            }
+            const buttons = [];
+            markup.rows.forEach((rowEntry, row) => {
+                rowEntry.buttons.forEach((button, col) => {
+                    buttons.push(describeKeyboardButton(button, row, col));
+                });
+            });
+            return { markupType: markup.className, buttons };
+        }, `getMessageButtons ${chatId}/${messageId}`);
+    }
+    async getBroadcastStats(chatId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Broadcast stats are only available for channels");
+            }
+            if (entity.megagroup) {
+                throw new Error("Broadcast stats are only available for broadcast channels, not supergroups (use telegram-get-megagroup-stats)");
+            }
+            let result;
+            try {
+                const response = await this.client?.invoke(new Api.stats.GetBroadcastStats({ channel: entity, dark: options?.dark }));
+                if (!response) {
+                    throw new Error("channel has no stats (may require Telegram Premium admin)");
+                }
+                result = response;
+            }
+            catch (e) {
+                const msg = e.message ?? String(e);
+                if (/CHAT_ADMIN_REQUIRED|ADMIN_RANK_INVALID/i.test(msg)) {
+                    throw new Error("Access denied: channel stats require admin rights (and may require Telegram Premium)");
+                }
+                if (/STATS_UNAVAILABLE|BROADCAST_REQUIRED|PARTICIPANTS_TOO_FEW/i.test(msg)) {
+                    throw new Error("channel has no stats (may require Telegram Premium admin)");
+                }
+                throw e;
+            }
+            return summarizeBroadcastStats(result, options?.includeGraphs === true);
+        }, `getBroadcastStats ${chatId}`);
+    }
+    async getMegagroupStats(chatId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Megagroup stats are only available for supergroups");
+            }
+            if (!entity.megagroup) {
+                throw new Error("Megagroup stats are only available for supergroups, not broadcast channels (use telegram-get-broadcast-stats)");
+            }
+            let result;
+            try {
+                const response = await this.client?.invoke(new Api.stats.GetMegagroupStats({ channel: entity, dark: options?.dark }));
+                if (!response) {
+                    throw new Error("supergroup has no stats yet (needs more activity/members)");
+                }
+                result = response;
+            }
+            catch (e) {
+                const msg = e.message ?? String(e);
+                if (/CHAT_ADMIN_REQUIRED|ADMIN_RANK_INVALID/i.test(msg)) {
+                    throw new Error("Access denied: supergroup stats require admin rights");
+                }
+                if (/STATS_UNAVAILABLE|PARTICIPANTS_TOO_FEW|MEGAGROUP_REQUIRED/i.test(msg)) {
+                    throw new Error("supergroup has no stats yet (needs more activity/members)");
+                }
+                throw e;
+            }
+            return summarizeMegagroupStats(result, options?.includeGraphs === true);
+        }, `getMegagroupStats ${chatId}`, { throwOnFloodWait: true });
+    }
+    async getUpdatesState() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const state = await this.client?.invoke(new Api.updates.GetState());
+            if (!state)
+                throw new Error("updates.GetState returned no state");
+            return {
+                pts: state.pts,
+                qts: state.qts,
+                date: state.date,
+                seq: state.seq,
+                unreadCount: state.unreadCount,
+            };
+        }, "getUpdatesState");
+    }
+    async getUpdates(cursor) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const ptsLimit = Math.min(cursor.ptsLimit ?? 100, 1000);
+        const ptsTotalLimit = Math.min(cursor.ptsTotalLimit ?? 1000, 1000);
+        return this.rateLimiter.execute(async () => {
+            const diff = await this.client?.invoke(new Api.updates.GetDifference({
+                pts: cursor.pts,
+                date: cursor.date,
+                qts: cursor.qts,
+                ptsLimit,
+                ptsTotalLimit,
+            }));
+            if (!diff)
+                throw new Error("updates.GetDifference returned nothing");
+            return summarizeUpdatesDifference(diff, cursor);
+        }, "getUpdates");
+    }
+    async getChannelUpdates(chatId, cursor) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const limit = Math.min(cursor.limit ?? 100, 1_000);
+        return this.rateLimiter.execute(async () => {
+            const entity = await this.resolveChat(chatId);
+            if (!(entity instanceof Api.Channel)) {
+                throw new Error("Channel updates are only available for channels/supergroups");
+            }
+            const diff = await this.client?.invoke(new Api.updates.GetChannelDifference({
+                channel: entity,
+                filter: new Api.ChannelMessagesFilterEmpty(),
+                pts: cursor.pts,
+                limit,
+                force: cursor.force,
+            }));
+            if (!diff)
+                throw new Error("updates.GetChannelDifference returned nothing");
+            return summarizeChannelDifference(diff, entity.id.toString(), cursor.pts);
+        }, `getChannelUpdates ${chatId}`);
+    }
     async createForumTopic(chatId, title, iconColor, iconEmojiId) {
         if (!this.client || !this.connected)
             throw new Error(NOT_CONNECTED_ERROR);
@@ -2690,4 +3800,216 @@ export class TelegramService {
             emoji: emojiMap.get(doc.id.toString()) || "",
         }));
     }
+    async getAllStories(options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.stories.GetAllStories({
+                next: options?.next,
+                hidden: options?.hidden,
+                state: options?.state,
+            }));
+            if (!response)
+                throw new Error("stories.GetAllStories returned nothing");
+            return summarizeAllStories(response);
+        }, "getAllStories");
+    }
+    async getPeerStories(chatId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.stories.GetPeerStories({ peer }));
+            if (!response)
+                throw new Error("stories.GetPeerStories returned nothing");
+            return summarizePeerStories(response.stories);
+        }, `getPeerStories ${chatId}`);
+    }
+    async getStoriesById(chatId, ids) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.stories.GetStoriesByID({ peer, id: ids }));
+            if (!response)
+                throw new Error("stories.GetStoriesByID returned nothing");
+            return summarizeStoriesById(response);
+        }, `getStoriesById ${chatId}`);
+    }
+    async getStoryViewsList(chatId, options) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.stories.GetStoryViewsList({
+                peer,
+                id: options.id,
+                q: options.q,
+                justContacts: options.justContacts,
+                reactionsFirst: options.reactionsFirst,
+                forwardsFirst: options.forwardsFirst,
+                offset: options.offset ?? "",
+                limit: options.limit ?? 50,
+            }));
+            if (!response)
+                throw new Error("stories.GetStoryViewsList returned nothing");
+            return summarizeStoryViewsList(response);
+        }, `getStoryViewsList ${chatId}/${options.id}`);
+    }
+    async getMyBoosts() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.premium.GetMyBoosts());
+            if (!response)
+                throw new Error("premium.GetMyBoosts returned nothing");
+            return summarizeMyBoosts(response);
+        }, "getMyBoosts");
+    }
+    async getBoostsStatus(chatId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.premium.GetBoostsStatus({ peer }));
+            if (!response)
+                throw new Error("premium.GetBoostsStatus returned nothing");
+            return summarizeBoostsStatus(response);
+        }, `getBoostsStatus ${chatId}`);
+    }
+    async getBoostsList(chatId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.premium.GetBoostsList({
+                peer,
+                gifts: options.gifts,
+                offset: options.offset ?? "",
+                limit: options.limit ?? 50,
+            }));
+            if (!response)
+                throw new Error("premium.GetBoostsList returned nothing");
+            return summarizeBoostsList(response);
+        }, `getBoostsList ${chatId}`);
+    }
+    async getBusinessChatLinks() {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.account.GetBusinessChatLinks());
+            if (!response)
+                throw new Error("account.GetBusinessChatLinks returned nothing");
+            return summarizeBusinessChatLinks(response);
+        }, "getBusinessChatLinks");
+    }
+    async getGroupCall(chatId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const call = await this.resolveInputGroupCall(chatId);
+            const response = await this.client?.invoke(new Api.phone.GetGroupCall({ call, limit: options.limit ?? 0 }));
+            if (!response)
+                throw new Error("phone.GetGroupCall returned nothing");
+            return summarizeGroupCall(response);
+        }, `getGroupCall ${chatId}`);
+    }
+    async getGroupCallParticipants(chatId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const call = await this.resolveInputGroupCall(chatId);
+            const ids = [];
+            for (const id of options.ids ?? []) {
+                ids.push(await this.resolvePeer(id));
+            }
+            const response = await this.client?.invoke(new Api.phone.GetGroupParticipants({
+                call,
+                ids,
+                sources: options.sources ?? [],
+                offset: options.offset ?? "",
+                limit: options.limit ?? 100,
+            }));
+            if (!response)
+                throw new Error("phone.GetGroupParticipants returned nothing");
+            return summarizeGroupCallParticipants(response);
+        }, `getGroupCallParticipants ${chatId}`);
+    }
+    async getStarsStatus(chatId) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.payments.GetStarsStatus({ peer }));
+            if (!response)
+                throw new Error("payments.GetStarsStatus returned nothing");
+            return summarizeStarsStatus(response);
+        }, `getStarsStatus ${chatId}`);
+    }
+    async getStarsTransactions(chatId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        const peer = await this.resolvePeer(chatId);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.payments.GetStarsTransactions({
+                peer,
+                inbound: options.inbound,
+                outbound: options.outbound,
+                ascending: options.ascending,
+                subscriptionId: options.subscriptionId,
+                offset: options.offset ?? "",
+                limit: options.limit ?? 50,
+            }));
+            if (!response)
+                throw new Error("payments.GetStarsTransactions returned nothing");
+            return summarizeStarsStatus(response);
+        }, `getStarsTransactions ${chatId}`);
+    }
+    async getQuickReplies(hash) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.messages.GetQuickReplies({ hash: hash ? bigInt(hash) : bigInt(0) }));
+            if (!response)
+                throw new Error("messages.GetQuickReplies returned nothing");
+            return summarizeQuickReplies(response);
+        }, "getQuickReplies");
+    }
+    async getQuickReplyMessages(shortcutId, options = {}) {
+        if (!this.client || !this.connected)
+            throw new Error(NOT_CONNECTED_ERROR);
+        return this.rateLimiter.execute(async () => {
+            const response = await this.client?.invoke(new Api.messages.GetQuickReplyMessages({
+                shortcutId,
+                id: options.ids,
+                hash: options.hash ? bigInt(options.hash) : bigInt(0),
+            }));
+            if (!response)
+                throw new Error("messages.GetQuickReplyMessages returned nothing");
+            return summarizeQuickReplyMessages(response);
+        }, `getQuickReplyMessages ${shortcutId}`);
+    }
+    async resolveInputGroupCall(chatId) {
+        const entity = await this.resolveChat(chatId);
+        let call;
+        if (entity instanceof Api.Channel) {
+            const full = await this.client?.invoke(new Api.channels.GetFullChannel({ channel: entity }));
+            if (full?.fullChat instanceof Api.ChannelFull) {
+                call = full.fullChat.call;
+            }
+        }
+        else if (entity instanceof Api.Chat) {
+            const full = await this.client?.invoke(new Api.messages.GetFullChat({ chatId: entity.id }));
+            if (full?.fullChat instanceof Api.ChatFull) {
+                call = full.fullChat.call;
+            }
+        }
+        else {
+            throw new Error("Group calls are only available for groups/supergroups/channels");
+        }
+        if (!call) {
+            throw new Error(`No active group call in chat ${chatId}`);
+        }
+        return call;
+    }
 }