@overpod/mcp-telegram 1.24.1 → 1.26.0

package/dist/__tests__/reactions.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import bigInt from "big-integer";
+import { Api } from "telegram/tl/index.js";
+import { reactionToEmoji } from "../telegram-client.js";
+describe("reactionToEmoji", () => {
+    it("returns emoticon for ReactionEmoji", () => {
+        const r = new Api.ReactionEmoji({ emoticon: "👍" });
+        assert.strictEqual(reactionToEmoji(r), "👍");
+    });
+    it("returns custom:<id> for ReactionCustomEmoji", () => {
+        const r = new Api.ReactionCustomEmoji({ documentId: bigInt(12345) });
+        assert.strictEqual(reactionToEmoji(r), "custom:12345");
+    });
+    it("returns star for ReactionPaid", () => {
+        const r = new Api.ReactionPaid();
+        assert.strictEqual(reactionToEmoji(r), "⭐");
+    });
+    it("returns null for ReactionEmpty", () => {
+        const r = new Api.ReactionEmpty();
+        assert.strictEqual(reactionToEmoji(r), null);
+    });
+});

package/dist/__tests__/set-chat-permissions-merge.test.d.ts

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

package/dist/__tests__/set-chat-permissions-merge.test.js

@@ -0,0 +1,107 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import bigInt from "big-integer";
+import { Api } from "telegram/tl/index.js";
+import { mergeBannedRights, TelegramService } from "../telegram-client.js";
+describe("mergeBannedRights", () => {
+    it("preserves omitted flags from current rights", () => {
+        const current = { pinMessages: true, inviteUsers: true, sendMessages: false };
+        const merged = mergeBannedRights(current, { sendMessages: false });
+        assert.strictEqual(merged.sendMessages, true, "user-specified denial applies");
+        assert.strictEqual(merged.pinMessages, true, "omitted flag stays banned");
+        assert.strictEqual(merged.inviteUsers, true, "omitted flag stays banned");
+        assert.strictEqual(merged.sendMedia, false, "omitted flag with no current stays unbanned");
+    });
+    it("user-provided value overrides current", () => {
+        const current = { pinMessages: true };
+        const merged = mergeBannedRights(current, { pinMessages: true });
+        assert.strictEqual(merged.pinMessages, false, "pinMessages:true allowed -> not banned");
+    });
+    it("fills missing flags with false when current is undefined", () => {
+        const merged = mergeBannedRights(undefined, { sendMessages: true });
+        assert.strictEqual(merged.sendMessages, false);
+        assert.strictEqual(merged.sendMedia, false);
+        assert.strictEqual(merged.pinMessages, false);
+    });
+    it("covers all nineteen flags (10 exposed + 9 extra preserved)", () => {
+        const merged = mergeBannedRights(undefined, {});
+        const keys = Object.keys(merged).sort();
+        assert.deepStrictEqual(keys, [
+            "changeInfo",
+            "embedLinks",
+            "inviteUsers",
+            "manageTopics",
+            "pinMessages",
+            "sendAudios",
+            "sendDocs",
+            "sendGames",
+            "sendGifs",
+            "sendInline",
+            "sendMedia",
+            "sendMessages",
+            "sendPhotos",
+            "sendPlain",
+            "sendPolls",
+            "sendRoundvideos",
+            "sendStickers",
+            "sendVideos",
+            "sendVoices",
+        ]);
+    });
+});
+describe("TelegramService.setChatPermissions", () => {
+    it("merges new permissions with existing defaultBannedRights", async () => {
+        const existingRights = new Api.ChatBannedRights({
+            untilDate: 0,
+            pinMessages: true,
+            inviteUsers: true,
+        });
+        const channel = new Api.Channel({
+            id: bigInt(12345),
+            title: "test",
+            photo: new Api.ChatPhotoEmpty(),
+            date: 0,
+            accessHash: bigInt(1),
+            defaultBannedRights: existingRights,
+        });
+        const inputChannel = new Api.InputPeerChannel({ channelId: bigInt(12345), accessHash: bigInt(1) });
+        const invocations = [];
+        const fakeClient = {
+            invoke: async (req) => {
+                invocations.push(req);
+                if (req instanceof Api.channels.GetFullChannel) {
+                    return new Api.messages.ChatFull({
+                        fullChat: new Api.ChannelFull({
+                            id: bigInt(12345),
+                            about: "",
+                            readInboxMaxId: 0,
+                            readOutboxMaxId: 0,
+                            unreadCount: 0,
+                            chatPhoto: new Api.PhotoEmpty({ id: bigInt(0) }),
+                            notifySettings: new Api.PeerNotifySettings({}),
+                            pts: 0,
+                            botInfo: [],
+                        }),
+                        chats: [channel],
+                        users: [],
+                    });
+                }
+                return undefined;
+            },
+            getInputEntity: async () => inputChannel,
+        };
+        const service = new TelegramService(1, "hash");
+        const internals = service;
+        internals.client = fakeClient;
+        internals.connected = true;
+        internals.resolveChat = async () => channel;
+        await service.setChatPermissions("12345", { sendMessages: false });
+        const editCall = invocations.find((r) => r instanceof Api.messages.EditChatDefaultBannedRights);
+        assert.ok(editCall, "EditChatDefaultBannedRights was invoked");
+        const rights = editCall.bannedRights;
+        assert.strictEqual(rights.sendMessages, true, "sendMessages becomes banned");
+        assert.strictEqual(rights.pinMessages, true, "pinMessages stays banned (preserved)");
+        assert.strictEqual(rights.inviteUsers, true, "inviteUsers stays banned (preserved)");
+        assert.strictEqual(rights.sendMedia, false, "omitted flag with no prior value stays unbanned");
+    });
+});

package/dist/__tests__/set-chat-reactions.test.d.ts

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

package/dist/__tests__/set-chat-reactions.test.js

@@ -0,0 +1,129 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import bigInt from "big-integer";
+import { Api } from "telegram/tl/index.js";
+import { TelegramService } from "../telegram-client.js";
+function makeService(entity, invocations) {
+    const fakeClient = {
+        invoke: async (req) => {
+            invocations.push(req);
+            return undefined;
+        },
+    };
+    const service = new TelegramService(1, "hash");
+    const internals = service;
+    internals.client = fakeClient;
+    internals.connected = true;
+    internals.resolveChat = async () => entity;
+    return service;
+}
+describe("TelegramService.setChatAvailableReactions", () => {
+    it("sends ChatReactionsAll without custom when type='all'", async () => {
+        const channel = new Api.Channel({
+            id: bigInt(12345),
+            title: "channel",
+            photo: new Api.ChatPhotoEmpty(),
+            date: 0,
+            accessHash: bigInt(1),
+            megagroup: true,
+        });
+        const invocations = [];
+        const service = makeService(channel, invocations);
+        await service.setChatAvailableReactions("12345", { type: "all" });
+        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
+        assert.ok(call, "SetChatAvailableReactions was invoked");
+        assert.ok(call.availableReactions instanceof Api.ChatReactionsAll);
+        assert.strictEqual(call.availableReactions.allowCustom, undefined);
+    });
+    it("sends ChatReactionsAll with allowCustom=true when requested", async () => {
+        const channel = new Api.Channel({
+            id: bigInt(22222),
+            title: "channel",
+            photo: new Api.ChatPhotoEmpty(),
+            date: 0,
+            accessHash: bigInt(1),
+            megagroup: true,
+        });
+        const invocations = [];
+        const service = makeService(channel, invocations);
+        await service.setChatAvailableReactions("22222", { type: "all", allowCustom: true });
+        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
+        assert.ok(call);
+        assert.ok(call.availableReactions instanceof Api.ChatReactionsAll);
+        assert.strictEqual(call.availableReactions.allowCustom, true);
+    });
+    it("sends ChatReactionsNone when type='none'", async () => {
+        const channel = new Api.Channel({
+            id: bigInt(33333),
+            title: "channel",
+            photo: new Api.ChatPhotoEmpty(),
+            date: 0,
+            accessHash: bigInt(1),
+            megagroup: true,
+        });
+        const invocations = [];
+        const service = makeService(channel, invocations);
+        await service.setChatAvailableReactions("33333", { type: "none" });
+        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
+        assert.ok(call);
+        assert.ok(call.availableReactions instanceof Api.ChatReactionsNone);
+    });
+    it("sends ChatReactionsSome with ReactionEmoji list when type='some'", async () => {
+        const channel = new Api.Channel({
+            id: bigInt(44444),
+            title: "channel",
+            photo: new Api.ChatPhotoEmpty(),
+            date: 0,
+            accessHash: bigInt(1),
+            megagroup: true,
+        });
+        const invocations = [];
+        const service = makeService(channel, invocations);
+        await service.setChatAvailableReactions("44444", { type: "some", emoji: ["👍", "❤️", "🔥"] });
+        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
+        assert.ok(call);
+        assert.ok(call.availableReactions instanceof Api.ChatReactionsSome);
+        const some = call.availableReactions;
+        assert.strictEqual(some.reactions.length, 3);
+        for (const r of some.reactions) {
+            assert.ok(r instanceof Api.ReactionEmoji);
+        }
+        assert.deepStrictEqual(some.reactions.map((r) => r.emoticon), ["👍", "❤️", "🔥"]);
+    });
+    it("accepts basic Chat entity (non-channel group)", async () => {
+        const chat = new Api.Chat({
+            id: bigInt(55555),
+            title: "basic group",
+            photo: new Api.ChatPhotoEmpty(),
+            participantsCount: 5,
+            date: 0,
+            version: 0,
+        });
+        const invocations = [];
+        const service = makeService(chat, invocations);
+        await service.setChatAvailableReactions("55555", { type: "none" });
+        const call = invocations.find((r) => r instanceof Api.messages.SetChatAvailableReactions);
+        assert.ok(call, "SetChatAvailableReactions was invoked for basic group");
+    });
+    it("rejects User peer (non-chat)", async () => {
+        const user = new Api.User({ id: bigInt(66666), accessHash: bigInt(1), firstName: "Bob" });
+        const invocations = [];
+        const service = makeService(user, invocations);
+        await assert.rejects(service.setChatAvailableReactions("66666", { type: "none" }), /groups, supergroups, and channels/);
+        assert.strictEqual(invocations.length, 0);
+    });
+    it("rejects empty emoji list on type='some'", async () => {
+        const channel = new Api.Channel({
+            id: bigInt(77777),
+            title: "channel",
+            photo: new Api.ChatPhotoEmpty(),
+            date: 0,
+            accessHash: bigInt(1),
+            megagroup: true,
+        });
+        const invocations = [];
+        const service = makeService(channel, invocations);
+        await assert.rejects(service.setChatAvailableReactions("77777", { type: "some", emoji: [] }), /non-empty/);
+        assert.strictEqual(invocations.length, 0);
+    });
+});

package/dist/__tests__/stars-status.test.d.ts

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

package/dist/__tests__/stars-status.test.js

@@ -0,0 +1,205 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import bigInt from "big-integer";
+import { Api } from "telegram/tl/index.js";
+import { summarizeStarsAmount, summarizeStarsStatus, summarizeStarsSubscription, summarizeStarsTransaction, summarizeStarsTransactionPeer, TelegramService, } from "../telegram-client.js";
+import { isStarsEnabled } from "../tools/stars.js";
+function makeService(invocations, responder) {
+    const fakeClient = {
+        invoke: async (req) => {
+            invocations.push(req);
+            return responder(req);
+        },
+    };
+    const service = new TelegramService(1, "hash");
+    const internals = service;
+    internals.client = fakeClient;
+    internals.connected = true;
+    return service;
+}
+describe("summarizeStarsAmount", () => {
+    it("stringifies amount (bigInt) and passes nanos through", () => {
+        const out = summarizeStarsAmount(new Api.StarsAmount({ amount: bigInt(12345), nanos: 67 }));
+        assert.deepStrictEqual(out, { amount: "12345", nanos: 67 });
+    });
+});
+describe("summarizeStarsTransactionPeer", () => {
+    it("maps app/play/premiumBot/fragment/ads/api/unsupported", () => {
+        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerAppStore()), { kind: "appStore" });
+        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerPlayMarket()), {
+            kind: "playMarket",
+        });
+        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerPremiumBot()), {
+            kind: "premiumBot",
+        });
+        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerFragment()), { kind: "fragment" });
+        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerAds()), { kind: "ads" });
+        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerAPI()), { kind: "api" });
+        assert.deepStrictEqual(summarizeStarsTransactionPeer(new Api.StarsTransactionPeerUnsupported()), {
+            kind: "unsupported",
+        });
+    });
+    it("maps StarsTransactionPeer with a user peer", () => {
+        const out = summarizeStarsTransactionPeer(new Api.StarsTransactionPeer({ peer: new Api.PeerUser({ userId: bigInt(42) }) }));
+        assert.deepStrictEqual(out, { kind: "peer", peer: { kind: "user", id: "42" } });
+    });
+});
+describe("summarizeStarsTransaction", () => {
+    it("maps core fields and flags", () => {
+        const tx = new Api.StarsTransaction({
+            id: "tx-1",
+            stars: new Api.StarsAmount({ amount: bigInt(500), nanos: 0 }),
+            date: 1710000000,
+            peer: new Api.StarsTransactionPeerAppStore(),
+            refund: true,
+            gift: true,
+            title: "Top-up",
+            msgId: 55,
+            transactionDate: 1710000100,
+            transactionUrl: "https://example.com/x",
+        });
+        const out = summarizeStarsTransaction(tx);
+        assert.strictEqual(out.id, "tx-1");
+        assert.deepStrictEqual(out.stars, { amount: "500", nanos: 0 });
+        assert.strictEqual(out.date, 1710000000);
+        assert.deepStrictEqual(out.peer, { kind: "appStore" });
+        assert.strictEqual(out.refund, true);
+        assert.strictEqual(out.gift, true);
+        assert.strictEqual(out.title, "Top-up");
+        assert.strictEqual(out.msgId, 55);
+        assert.strictEqual(out.transactionDate, 1710000100);
+        assert.strictEqual(out.transactionUrl, "https://example.com/x");
+        assert.strictEqual(out.description, undefined);
+    });
+});
+describe("summarizeStarsSubscription", () => {
+    it("maps id, peer, pricing and flags", () => {
+        const sub = new Api.StarsSubscription({
+            id: "sub-1",
+            peer: new Api.PeerChannel({ channelId: bigInt(100) }),
+            untilDate: 1720000000,
+            pricing: new Api.StarsSubscriptionPricing({ period: 2592000, amount: bigInt(150) }),
+            canceled: true,
+            title: "Premium group",
+            invoiceSlug: "slug-x",
+        });
+        const out = summarizeStarsSubscription(sub);
+        assert.strictEqual(out.id, "sub-1");
+        assert.deepStrictEqual(out.peer, { kind: "channel", id: "100" });
+        assert.strictEqual(out.untilDate, 1720000000);
+        assert.deepStrictEqual(out.pricing, { period: 2592000, amount: "150" });
+        assert.strictEqual(out.canceled, true);
+        assert.strictEqual(out.title, "Premium group");
+        assert.strictEqual(out.invoiceSlug, "slug-x");
+        assert.strictEqual(out.missingBalance, undefined);
+    });
+});
+describe("summarizeStarsStatus", () => {
+    it("maps balance, history, subscriptions and offsets", () => {
+        const resp = new Api.payments.StarsStatus({
+            balance: new Api.StarsAmount({ amount: bigInt(1000), nanos: 5 }),
+            history: [
+                new Api.StarsTransaction({
+                    id: "t1",
+                    stars: new Api.StarsAmount({ amount: bigInt(10), nanos: 0 }),
+                    date: 1,
+                    peer: new Api.StarsTransactionPeerPremiumBot(),
+                }),
+            ],
+            subscriptions: [
+                new Api.StarsSubscription({
+                    id: "s1",
+                    peer: new Api.PeerChannel({ channelId: bigInt(7) }),
+                    untilDate: 100,
+                    pricing: new Api.StarsSubscriptionPricing({ period: 30, amount: bigInt(5) }),
+                }),
+            ],
+            subscriptionsNextOffset: "sub-cursor",
+            subscriptionsMissingBalance: bigInt(250),
+            nextOffset: "tx-cursor",
+            chats: [],
+            users: [],
+        });
+        const out = summarizeStarsStatus(resp);
+        assert.deepStrictEqual(out.balance, { amount: "1000", nanos: 5 });
+        assert.strictEqual(out.history?.length, 1);
+        assert.strictEqual(out.history?.[0].id, "t1");
+        assert.strictEqual(out.subscriptions?.length, 1);
+        assert.strictEqual(out.subscriptions?.[0].id, "s1");
+        assert.strictEqual(out.subscriptionsNextOffset, "sub-cursor");
+        assert.strictEqual(out.subscriptionsMissingBalance, "250");
+        assert.strictEqual(out.nextOffset, "tx-cursor");
+    });
+    it("omits empty history/subscriptions and empty offset strings", () => {
+        const resp = new Api.payments.StarsStatus({
+            balance: new Api.StarsAmount({ amount: bigInt(0), nanos: 0 }),
+            history: [],
+            subscriptions: [],
+            subscriptionsNextOffset: "",
+            nextOffset: "",
+            chats: [],
+            users: [],
+        });
+        const out = summarizeStarsStatus(resp);
+        assert.strictEqual(out.history, undefined);
+        assert.strictEqual(out.subscriptions, undefined);
+        assert.strictEqual(out.subscriptionsNextOffset, undefined);
+        assert.strictEqual(out.nextOffset, undefined);
+        assert.strictEqual(out.subscriptionsMissingBalance, undefined);
+    });
+});
+describe("TelegramService.getStarsStatus", () => {
+    it("invokes payments.GetStarsStatus with resolved peer and returns summary", async () => {
+        const invocations = [];
+        const service = makeService(invocations, () => new Api.payments.StarsStatus({
+            balance: new Api.StarsAmount({ amount: bigInt(42), nanos: 0 }),
+            chats: [],
+            users: [],
+        }));
+        const internals = service;
+        internals.resolvePeer = async (_id) => new Api.InputPeerUser({ userId: bigInt(1), accessHash: bigInt(2) });
+        const out = await service.getStarsStatus("me");
+        const call = invocations.find((r) => r instanceof Api.payments.GetStarsStatus);
+        assert.ok(call);
+        assert.deepStrictEqual(out.balance, { amount: "42", nanos: 0 });
+    });
+});
+describe("isStarsEnabled gate", () => {
+    it("is off by default", () => {
+        const prev = process.env.MCP_TELEGRAM_ENABLE_STARS;
+        delete process.env.MCP_TELEGRAM_ENABLE_STARS;
+        try {
+            assert.strictEqual(isStarsEnabled(), false);
+        }
+        finally {
+            if (prev !== undefined)
+                process.env.MCP_TELEGRAM_ENABLE_STARS = prev;
+        }
+    });
+    it("turns on when env is '1'", () => {
+        const prev = process.env.MCP_TELEGRAM_ENABLE_STARS;
+        process.env.MCP_TELEGRAM_ENABLE_STARS = "1";
+        try {
+            assert.strictEqual(isStarsEnabled(), true);
+        }
+        finally {
+            if (prev === undefined)
+                delete process.env.MCP_TELEGRAM_ENABLE_STARS;
+            else
+                process.env.MCP_TELEGRAM_ENABLE_STARS = prev;
+        }
+    });
+    it("stays off for any non-'1' value", () => {
+        const prev = process.env.MCP_TELEGRAM_ENABLE_STARS;
+        process.env.MCP_TELEGRAM_ENABLE_STARS = "true";
+        try {
+            assert.strictEqual(isStarsEnabled(), false);
+        }
+        finally {
+            if (prev === undefined)
+                delete process.env.MCP_TELEGRAM_ENABLE_STARS;
+            else
+                process.env.MCP_TELEGRAM_ENABLE_STARS = prev;
+        }
+    });
+});

package/dist/__tests__/stars-transactions.test.d.ts

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

package/dist/__tests__/stars-transactions.test.js

@@ -0,0 +1,82 @@
+import assert from "node:assert";
+import { describe, it } from "node:test";
+import bigInt from "big-integer";
+import { Api } from "telegram/tl/index.js";
+import { TelegramService } from "../telegram-client.js";
+function makeService(invocations, responder) {
+    const fakeClient = {
+        invoke: async (req) => {
+            invocations.push(req);
+            return responder(req);
+        },
+    };
+    const service = new TelegramService(1, "hash");
+    const internals = service;
+    internals.client = fakeClient;
+    internals.connected = true;
+    return service;
+}
+describe("TelegramService.getStarsTransactions", () => {
+    it("invokes payments.GetStarsTransactions with resolved peer, default offset='' and limit=50", async () => {
+        const invocations = [];
+        const service = makeService(invocations, () => new Api.payments.StarsStatus({
+            balance: new Api.StarsAmount({ amount: bigInt(100), nanos: 0 }),
+            history: [
+                new Api.StarsTransaction({
+                    id: "tx-A",
+                    stars: new Api.StarsAmount({ amount: bigInt(25), nanos: 0 }),
+                    date: 1710000000,
+                    peer: new Api.StarsTransactionPeerAppStore(),
+                }),
+            ],
+            nextOffset: "next-cursor",
+            chats: [],
+            users: [],
+        }));
+        const internals = service;
+        internals.resolvePeer = async (_id) => new Api.InputPeerUser({ userId: bigInt(1), accessHash: bigInt(2) });
+        const out = await service.getStarsTransactions("me");
+        const call = invocations.find((r) => r instanceof Api.payments.GetStarsTransactions);
+        assert.ok(call, "GetStarsTransactions must be invoked");
+        assert.strictEqual(call.offset, "");
+        assert.strictEqual(call.limit, 50);
+        assert.strictEqual(call.inbound, undefined);
+        assert.strictEqual(call.outbound, undefined);
+        assert.strictEqual(call.ascending, undefined);
+        assert.strictEqual(call.subscriptionId, undefined);
+        assert.deepStrictEqual(out.balance, { amount: "100", nanos: 0 });
+        assert.strictEqual(out.history?.length, 1);
+        assert.strictEqual(out.history?.[0].id, "tx-A");
+        assert.strictEqual(out.nextOffset, "next-cursor");
+    });
+    it("forwards filter and pagination options verbatim", async () => {
+        const invocations = [];
+        const service = makeService(invocations, () => new Api.payments.StarsStatus({
+            balance: new Api.StarsAmount({ amount: bigInt(0), nanos: 0 }),
+            chats: [],
+            users: [],
+        }));
+        const internals = service;
+        internals.resolvePeer = async (_id) => new Api.InputPeerUser({ userId: bigInt(7), accessHash: bigInt(8) });
+        await service.getStarsTransactions("me", {
+            inbound: true,
+            outbound: false,
+            ascending: true,
+            subscriptionId: "sub-9",
+            offset: "cursor-xyz",
+            limit: 25,
+        });
+        const call = invocations.find((r) => r instanceof Api.payments.GetStarsTransactions);
+        assert.ok(call);
+        assert.strictEqual(call.inbound, true);
+        assert.strictEqual(call.outbound, false);
+        assert.strictEqual(call.ascending, true);
+        assert.strictEqual(call.subscriptionId, "sub-9");
+        assert.strictEqual(call.offset, "cursor-xyz");
+        assert.strictEqual(call.limit, 25);
+    });
+    it("throws when not connected", async () => {
+        const service = new TelegramService(1, "hash");
+        await assert.rejects(() => service.getStarsTransactions("me"), /Not connected/i);
+    });
+});

package/dist/__tests__/stories.test.d.ts

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