@maxhub/max-bot-api 0.2.1

package/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2024 juice development LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/api.d.ts

@@ -0,0 +1,42 @@
+import { AudioAttachment, FileAttachment, ImageAttachment, VideoAttachment } from './core/helpers/attachments';
+import type { MaybeArray } from './core/helpers/types';
+import { Upload } from './core/helpers/upload';
+import type { UploadFileOptions, UploadImageOptions, UploadVideoOptions, UploadAudioOptions } from './core/helpers/upload';
+import { GetMessagesExtra, RawApi, SenderAction } from './core/network/api';
+import type { AnswerOnCallbackExtra, Client, DeleteMessageExtra, EditMessageExtra, SendMessageExtra, BotCommand, EditMyInfoDTO, FlattenReq, GetUpdatesDTO, UpdateType } from './core/network/api';
+import type { EditChatExtra, GetAllChatsExtra, GetChatMembersExtra, PinMessageExtra } from './core/network/api/modules';
+export declare class Api {
+    raw: RawApi;
+    upload: Upload;
+    constructor(client: Client);
+    getMyInfo: () => Promise<import("./core/network/api").BotInfo>;
+    editMyInfo: (extra: FlattenReq<EditMyInfoDTO>) => Promise<import("./core/network/api").BotInfo>;
+    setMyCommands: (commands: BotCommand[]) => Promise<import("./core/network/api").BotInfo>;
+    deleteMyCommands: () => Promise<import("./core/network/api").BotInfo>;
+    getAllChats: (extra?: GetAllChatsExtra) => Promise<import("./core/network/api/modules").GetAllChatsResponse>;
+    getChat: (id: number) => Promise<import("./core/network/api").Chat>;
+    getChatByLink: (link: string) => Promise<import("./core/network/api").Chat>;
+    editChatInfo: (chatId: number, extra: EditChatExtra) => Promise<import("./core/network/api").Chat>;
+    sendMessageToChat: (chatId: number, text: string, extra?: SendMessageExtra) => Promise<import("./core/network/api").Message>;
+    sendMessageToUser: (userId: number, text: string, extra?: SendMessageExtra) => Promise<import("./core/network/api").Message>;
+    getMessages: (chatId: number, { message_ids, ...extra }?: GetMessagesExtra) => Promise<import("./core/network/api").GetMessagesResponse>;
+    getMessage: (id: string) => Promise<import("./core/network/api").Message>;
+    editMessage: (messageId: string, extra?: EditMessageExtra) => Promise<import("./core/network/api").ActionResponse>;
+    deleteMessage: (messageId: string, extra?: DeleteMessageExtra) => Promise<import("./core/network/api").ActionResponse>;
+    answerOnCallback: (callbackId: string, extra?: AnswerOnCallbackExtra) => Promise<import("./core/network/api").ActionResponse>;
+    getChatMembership: (chatId: number) => Promise<import("./core/network/api").ChatMember>;
+    getChatAdmins: (chatId: number) => Promise<import("./core/network/api/modules").GetChatAdminsResponse>;
+    addChatMembers: (chatId: number, userIds: number[]) => Promise<import("./core/network/api").ActionResponse>;
+    getChatMembers: (chatId: number, { user_ids, ...extra }?: GetChatMembersExtra) => Promise<import("./core/network/api/modules").GetChatMembersResponse>;
+    removeChatMember: (chatId: number, userId: number) => Promise<import("./core/network/api").ActionResponse>;
+    getUpdates: (types?: MaybeArray<UpdateType>, extra?: Omit<FlattenReq<GetUpdatesDTO>, "types">) => Promise<import("./core/network/api").GetUpdatesResponse>;
+    getPinnedMessage: (chatId: number) => Promise<import("./core/network/api/modules").GetPinnedMessageResponse>;
+    pinMessage: (chatId: number, messageId: string, extra?: PinMessageExtra) => Promise<import("./core/network/api").ActionResponse>;
+    unpinMessage: (chatId: number) => Promise<import("./core/network/api").ActionResponse>;
+    sendAction: (chatId: number, action: SenderAction) => Promise<import("./core/network/api").ActionResponse>;
+    leaveChat: (chatId: number) => Promise<import("./core/network/api").ActionResponse>;
+    uploadImage: (options: UploadImageOptions) => Promise<ImageAttachment>;
+    uploadVideo: (options: UploadVideoOptions) => Promise<VideoAttachment>;
+    uploadAudio: (options: UploadAudioOptions) => Promise<AudioAttachment>;
+    uploadFile: (options: UploadFileOptions) => Promise<FileAttachment>;
+}

package/dist/api.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = void 0;
+const attachments_1 = require("./core/helpers/attachments");
+const upload_1 = require("./core/helpers/upload");
+const api_1 = require("./core/network/api");
+class Api {
+    constructor(client) {
+        this.getMyInfo = async () => {
+            return this.raw.bots.getMyInfo();
+        };
+        this.editMyInfo = async (extra) => {
+            return this.raw.bots.editMyInfo(extra);
+        };
+        this.setMyCommands = async (commands) => {
+            return this.editMyInfo({ commands });
+        };
+        this.deleteMyCommands = async () => {
+            return this.editMyInfo({ commands: [] });
+        };
+        this.getAllChats = async (extra = {}) => {
+            return this.raw.chats.getAll(extra);
+        };
+        this.getChat = async (id) => {
+            return this.raw.chats.getById({ chat_id: id });
+        };
+        this.getChatByLink = async (link) => {
+            return this.raw.chats.getByLink({ chat_link: link });
+        };
+        this.editChatInfo = async (chatId, extra) => {
+            return this.raw.chats.edit({ chat_id: chatId, ...extra });
+        };
+        this.sendMessageToChat = async (chatId, text, extra) => {
+            const { message } = await this.raw.messages.send({
+                chat_id: chatId,
+                text,
+                ...extra,
+            });
+            return message;
+        };
+        this.sendMessageToUser = async (userId, text, extra) => {
+            const { message } = await this.raw.messages.send({
+                user_id: userId,
+                text,
+                ...extra,
+            });
+            return message;
+        };
+        this.getMessages = async (chatId, { message_ids, ...extra } = {}) => {
+            return this.raw.messages.get({
+                chat_id: chatId,
+                message_ids: message_ids?.join(','),
+                ...extra,
+            });
+        };
+        this.getMessage = async (id) => {
+            return this.raw.messages.getById({ message_id: id });
+        };
+        this.editMessage = async (messageId, extra) => {
+            return this.raw.messages.edit({
+                message_id: messageId,
+                ...extra,
+            });
+        };
+        this.deleteMessage = async (messageId, extra) => {
+            return this.raw.messages.delete({ message_id: messageId, ...extra });
+        };
+        this.answerOnCallback = async (callbackId, extra) => {
+            return this.raw.messages.answerOnCallback({ callback_id: callbackId, ...extra });
+        };
+        this.getChatMembership = (chatId) => {
+            return this.raw.chats.getChatMembership({ chat_id: chatId });
+        };
+        this.getChatAdmins = (chatId) => {
+            return this.raw.chats.getChatAdmins({ chat_id: chatId });
+        };
+        this.addChatMembers = (chatId, userIds) => {
+            return this.raw.chats.addChatMembers({
+                chat_id: chatId,
+                user_ids: userIds,
+            });
+        };
+        this.getChatMembers = (chatId, { user_ids, ...extra } = {}) => {
+            return this.raw.chats.getChatMembers({
+                chat_id: chatId,
+                user_ids: user_ids?.join(','),
+                ...extra,
+            });
+        };
+        this.removeChatMember = (chatId, userId) => {
+            return this.raw.chats.removeChatMember({
+                chat_id: chatId,
+                user_id: userId,
+            });
+        };
+        this.getUpdates = async (types = [], extra = {}) => {
+            return this.raw.subscriptions.getUpdates({
+                types: Array.isArray(types) ? types.join(',') : types,
+                ...extra,
+            });
+        };
+        this.getPinnedMessage = async (chatId) => {
+            return this.raw.chats.getPinnedMessage({ chat_id: chatId });
+        };
+        this.pinMessage = async (chatId, messageId, extra) => {
+            return this.raw.chats.pinMessage({
+                chat_id: chatId,
+                message_id: messageId,
+                ...extra,
+            });
+        };
+        this.unpinMessage = async (chatId) => {
+            return this.raw.chats.unpinMessage({ chat_id: chatId });
+        };
+        this.sendAction = async (chatId, action) => {
+            return this.raw.chats.sendAction({
+                chat_id: chatId,
+                action,
+            });
+        };
+        this.leaveChat = async (chatId) => {
+            return this.raw.chats.leaveChat({ chat_id: chatId });
+        };
+        this.uploadImage = async (options) => {
+            const data = await this.upload.image(options);
+            return new attachments_1.ImageAttachment(data);
+        };
+        this.uploadVideo = async (options) => {
+            const data = await this.upload.video(options);
+            return new attachments_1.VideoAttachment({ token: data.token });
+        };
+        this.uploadAudio = async (options) => {
+            const data = await this.upload.audio(options);
+            return new attachments_1.AudioAttachment({ token: data.token });
+        };
+        this.uploadFile = async (options) => {
+            const data = await this.upload.file(options);
+            return new attachments_1.FileAttachment({ token: data.token });
+        };
+        this.raw = new api_1.RawApi(client);
+        this.upload = new upload_1.Upload(this);
+    }
+}
+exports.Api = Api;

package/dist/bot.d.ts

@@ -0,0 +1,26 @@
+import { Composer } from './composer';
+import { Context } from './context';
+import { MaybePromise } from './core/helpers/types';
+import { BotInfo, ClientOptions, UpdateType } from './core/network/api';
+import { Api } from './api';
+type BotConfig<Ctx extends Context> = {
+    clientOptions?: ClientOptions;
+    contextType: new (...args: ConstructorParameters<typeof Context>) => Ctx;
+};
+type LaunchOptions = {
+    allowedUpdates: UpdateType[];
+};
+export declare class Bot<Ctx extends Context = Context> extends Composer<Ctx> {
+    api: Api;
+    botInfo?: BotInfo;
+    private polling?;
+    private pollingIsStarted;
+    private config;
+    constructor(token: string, config?: Partial<BotConfig<Ctx>>);
+    private handleError;
+    catch(handler: (err: unknown, ctx: Ctx) => MaybePromise<void>): this;
+    start: (options?: LaunchOptions) => Promise<void>;
+    stop: () => void;
+    private handleUpdate;
+}
+export {};

package/dist/bot.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bot = void 0;
+const debug_1 = __importDefault(require("debug"));
+const composer_1 = require("./composer");
+const context_1 = require("./context");
+const api_1 = require("./core/network/api");
+const polling_1 = require("./core/network/polling");
+const api_2 = require("./api");
+const debug = (0, debug_1.default)('one-me:main');
+const defaultConfig = {
+    contextType: context_1.Context,
+};
+class Bot extends composer_1.Composer {
+    constructor(token, config) {
+        super();
+        this.pollingIsStarted = false;
+        this.handleError = (err, ctx) => {
+            process.exitCode = 1;
+            console.error('Unhandled error while processing', ctx.update);
+            throw err;
+        };
+        this.start = async (options) => {
+            if (this.pollingIsStarted) {
+                debug('Long polling already running');
+                return;
+            }
+            this.pollingIsStarted = true;
+            this.botInfo ?? (this.botInfo = await this.api.getMyInfo());
+            this.polling = new polling_1.Polling(this.api, options?.allowedUpdates);
+            debug(`Starting @${this.botInfo.username}`);
+            await this.polling.loop(this.handleUpdate);
+        };
+        this.stop = () => {
+            if (!this.pollingIsStarted) {
+                debug('Long polling is not running');
+                return;
+            }
+            this.polling?.stop();
+            this.pollingIsStarted = false;
+        };
+        this.handleUpdate = async (update) => {
+            const updateId = `${update.update_type}:${update.timestamp}`;
+            debug(`Processing update ${updateId}`);
+            const UpdateContext = this.config.contextType;
+            const ctx = new UpdateContext(update, this.api, this.botInfo);
+            try {
+                await this.middleware()(ctx, () => Promise.resolve(undefined));
+            }
+            catch (err) {
+                await this.handleError(err, ctx);
+            }
+            finally {
+                debug(`Finished processing update ${updateId}`);
+            }
+        };
+        // @ts-ignore
+        this.config = { ...defaultConfig, ...config };
+        this.api = new api_2.Api((0, api_1.createClient)(token, this.config.clientOptions));
+        debug('Created `Bot` instance');
+    }
+    catch(handler) {
+        this.handleError = handler;
+        return this;
+    }
+}
+exports.Bot = Bot;

package/dist/composer.d.ts

@@ -0,0 +1,22 @@
+import type { Guard, MaybeArray } from './core/helpers/types';
+import type { UpdateType } from './core/network/api';
+import type { Middleware, MiddlewareFn, MiddlewareObj, NextFn } from './middleware';
+import { Context, type FilteredContext } from './context';
+type Triggers = MaybeArray<string | RegExp>;
+type UpdateFilter<Ctx extends Context> = UpdateType | Guard<Ctx['update']>;
+export declare class Composer<Ctx extends Context> implements MiddlewareObj<Ctx> {
+    private handler;
+    constructor(...middlewares: Array<Middleware<Ctx>>);
+    middleware(): MiddlewareFn<Ctx>;
+    use(...middlewares: Array<Middleware<Ctx>>): this;
+    on<Filter extends UpdateType | Guard<Ctx['update']>>(filters: MaybeArray<Filter>, ...middlewares: Array<Middleware<FilteredContext<Ctx, Filter>>>): this;
+    command(command: Triggers, ...middlewares: Array<Middleware<FilteredContext<Ctx, 'message_created'>>>): this;
+    hears(triggers: Triggers, ...middlewares: Array<Middleware<FilteredContext<Ctx, 'message_created'>>>): this;
+    action(triggers: Triggers, ...middlewares: Array<Middleware<FilteredContext<Ctx, 'message_callback'>>>): this;
+    filter<Filter extends UpdateFilter<Ctx>>(filters: MaybeArray<Filter>, ...middlewares: Array<Middleware<FilteredContext<Ctx, Filter>>>): MiddlewareFn<Ctx>;
+    static flatten<C extends Context>(mw: Middleware<C>): MiddlewareFn<C>;
+    static concat<C extends Context>(first: MiddlewareFn<C>, andThen: MiddlewareFn<C>): MiddlewareFn<C>;
+    static pass<C extends Context>(_ctx: C, next: NextFn): Promise<void>;
+    static compose<C extends Context>(middlewares: Array<Middleware<C>>): MiddlewareFn<C>;
+}
+export {};

package/dist/composer.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Composer = void 0;
+const filters_1 = require("./filters");
+class Composer {
+    constructor(...middlewares) {
+        this.handler = Composer.compose(middlewares);
+    }
+    middleware() {
+        return this.handler;
+    }
+    use(...middlewares) {
+        this.handler = Composer.compose([this.handler, ...middlewares]);
+        return this;
+    }
+    on(filters, ...middlewares) {
+        return this.use(this.filter(filters, ...middlewares));
+    }
+    command(command, ...middlewares) {
+        const normalizedTriggers = normalizeTriggers(command);
+        const filter = (0, filters_1.createdMessageBodyHas)('text');
+        const handler = Composer.compose(middlewares);
+        return this.use(this.filter(filter, (ctx, next) => {
+            const text = extractTextFromMessage(ctx.message, ctx.myId);
+            const cmd = text.slice(1);
+            for (const trigger of normalizedTriggers) {
+                const match = trigger(cmd);
+                if (match) {
+                    ctx.match = match;
+                    return handler(ctx, next);
+                }
+            }
+            return next();
+        }));
+    }
+    hears(triggers, ...middlewares) {
+        const normalizedTriggers = normalizeTriggers(triggers);
+        const filter = (0, filters_1.createdMessageBodyHas)('text');
+        const handler = Composer.compose(middlewares);
+        return this.use(this.filter(filter, (ctx, next) => {
+            const text = extractTextFromMessage(ctx.message, ctx.myId);
+            for (const trigger of normalizedTriggers) {
+                const match = trigger(text);
+                if (match) {
+                    ctx.match = match;
+                    return handler(ctx, next);
+                }
+            }
+            return next();
+        }));
+    }
+    action(triggers, ...middlewares) {
+        const normalizedTriggers = normalizeTriggers(triggers);
+        const handler = Composer.compose(middlewares);
+        return this.use(this.filter('message_callback', (ctx, next) => {
+            const { payload } = ctx.update.callback;
+            if (!payload)
+                return next();
+            for (const trigger of normalizedTriggers) {
+                const match = trigger(payload);
+                if (match) {
+                    ctx.match = match;
+                    return handler(ctx, next);
+                }
+            }
+            return next();
+        }));
+    }
+    filter(filters, ...middlewares) {
+        const handler = Composer.compose(middlewares);
+        return (ctx, next) => {
+            return ctx.has(filters) ? handler(ctx, next) : next();
+        };
+    }
+    static flatten(mw) {
+        return typeof mw === 'function'
+            ? mw
+            : (ctx, next) => mw.middleware()(ctx, next);
+    }
+    static concat(first, andThen) {
+        return async (ctx, next) => {
+            let nextCalled = false;
+            await first(ctx, async () => {
+                if (nextCalled) {
+                    throw new Error('`next` already called before!');
+                }
+                nextCalled = true;
+                await andThen(ctx, next);
+            });
+        };
+    }
+    static pass(_ctx, next) {
+        return next();
+    }
+    static compose(middlewares) {
+        if (!Array.isArray(middlewares)) {
+            throw new Error('Middlewares must be an array');
+        }
+        if (middlewares.length === 0) {
+            return Composer.pass;
+        }
+        return middlewares.map(Composer.flatten).reduce(Composer.concat);
+    }
+}
+exports.Composer = Composer;
+const normalizeTriggers = (triggers) => {
+    return (Array.isArray(triggers) ? triggers : [triggers]).map((trigger) => {
+        if (trigger instanceof RegExp) {
+            return (value = '') => {
+                // eslint-disable-next-line no-param-reassign
+                trigger.lastIndex = 0;
+                return trigger.exec(value.trim());
+            };
+        }
+        const regex = new RegExp(`^${trigger}$`);
+        return (value) => regex.exec(value.trim());
+    });
+};
+const extractTextFromMessage = (message, myId) => {
+    const { text } = message.body;
+    const mention = message.body.markup?.find((m) => {
+        return m.type === 'user_mention';
+    });
+    if (mention
+        && mention.from === 0
+        && mention.user_id === myId) {
+        return text?.slice(mention.length).trim();
+    }
+    return text;
+};

package/dist/context.d.ts

@@ -0,0 +1,85 @@
+import type { Guard, Guarded, MaybeArray } from './core/helpers/types';
+import type { AnswerOnCallbackExtra, BotInfo, BotStartedUpdate, Chat, EditMessageExtra, FilteredUpdate, GetMessagesExtra, Message, MessageCallbackUpdate, SenderAction, SendMessageExtra, Update, UpdateType, User } from './core/network/api';
+import { type Api } from './api';
+import { EditChatExtra, GetAllChatsExtra, GetChatMembersExtra, PinMessageExtra } from './core/network/api/modules';
+export type FilteredContext<Ctx extends Context, Filter extends UpdateType | Guard<Ctx['update']>> = Filter extends UpdateType ? Ctx & Context<FilteredUpdate<Filter>> : Ctx & Context<Guarded<Filter>>;
+type GetMessage<U extends Update> = U extends MessageCallbackUpdate ? MessageCallbackUpdate['message'] : U extends {
+    message: Message;
+} ? Message : undefined;
+type GetChatId<U extends Update> = U extends {
+    chat_id: number;
+} ? number : U extends MessageCallbackUpdate ? number | undefined : U extends {
+    message: Message;
+} ? number : undefined;
+type GetChat<U extends Update> = U extends {
+    chat: Chat;
+} ? Chat : undefined;
+type GetMsgId<U extends Update> = U extends {
+    message_id: string;
+} ? string : U extends MessageCallbackUpdate ? string | undefined : U extends {
+    message: Message;
+} ? string : undefined;
+type GetCallback<U extends Update> = U extends MessageCallbackUpdate ? MessageCallbackUpdate['callback'] : undefined;
+type GetUser<U extends Update> = U extends {
+    user: User;
+} ? User : U extends MessageCallbackUpdate ? User : undefined;
+type GetStartPayload<U extends Update> = U extends BotStartedUpdate ? string | undefined | null : undefined;
+type ContactInfo = {
+    tel?: string;
+    fullName?: string;
+};
+type Location = {
+    latitude: number;
+    longitude: number;
+};
+type Sticker = {
+    width: number;
+    height: number;
+    url: string;
+    code: string;
+};
+export declare class Context<U extends Update = Update> {
+    readonly update: U;
+    readonly api: Api;
+    readonly botInfo?: BotInfo | undefined;
+    match?: RegExpExecArray;
+    constructor(update: U, api: Api, botInfo?: BotInfo | undefined);
+    has<Ctx extends Context, Filter extends UpdateType | Guard<Ctx['update']>>(this: Ctx, filters: MaybeArray<Filter>): this is FilteredContext<Ctx, Filter>;
+    assert<T extends string | number | object>(value: T | undefined, method: string): asserts value is T;
+    get updateType(): "message_callback" | "message_created" | "message_removed" | "message_edited" | "bot_added" | "bot_removed" | "user_added" | "user_removed" | "bot_started" | "chat_title_changed" | "message_construction_request" | "message_constructed" | "message_chat_created";
+    get myId(): number | undefined;
+    get startPayload(): GetStartPayload<U>;
+    get chat(): GetChat<U>;
+    get chatId(): GetChatId<U>;
+    get message(): GetMessage<U>;
+    get messageId(): GetMsgId<U>;
+    get callback(): GetCallback<U>;
+    get user(): GetUser<U>;
+    private _contactInfo?;
+    get contactInfo(): ContactInfo | undefined;
+    private _location?;
+    get location(): Location | undefined;
+    private _sticker?;
+    get sticker(): Sticker | undefined;
+    reply(text: string, extra?: SendMessageExtra): Promise<Message>;
+    getAllChats(extra?: GetAllChatsExtra): Promise<import("./core/network/api/modules").GetAllChatsResponse>;
+    getChat(chatId?: number): Promise<Chat>;
+    getChatByLink(link: string): Promise<Chat>;
+    editChatInfo(extra: EditChatExtra): Promise<Chat>;
+    getMessage(id: string): Promise<Message>;
+    getMessages(extra?: GetMessagesExtra): Promise<import("./core/network/api").GetMessagesResponse>;
+    getPinnedMessage(): Promise<import("./core/network/api/modules").GetPinnedMessageResponse>;
+    editMessage(extra: EditMessageExtra): Promise<import("./core/network/api").ActionResponse>;
+    deleteMessage(messageId?: string): Promise<import("./core/network/api").ActionResponse>;
+    answerOnCallback(extra: AnswerOnCallbackExtra): Promise<import("./core/network/api").ActionResponse>;
+    getChatMembership(): Promise<import("./core/network/api").ChatMember>;
+    getChatAdmins(): Promise<import("./core/network/api/modules").GetChatAdminsResponse>;
+    addChatMembers(userIds: number[]): Promise<import("./core/network/api").ActionResponse>;
+    getChatMembers(extra?: GetChatMembersExtra): Promise<import("./core/network/api/modules").GetChatMembersResponse>;
+    removeChatMember(userId: number): Promise<import("./core/network/api").ActionResponse>;
+    pinMessage(messageId: string, extra?: PinMessageExtra): Promise<import("./core/network/api").ActionResponse>;
+    unpinMessage(): Promise<import("./core/network/api").ActionResponse>;
+    sendAction(action: SenderAction): Promise<import("./core/network/api").ActionResponse>;
+    leaveChat(): Promise<import("./core/network/api").ActionResponse>;
+}
+export {};