@kotori-bot/core 1.1.0

package/lib/base/message.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+const tsukiko_1 = __importDefault(require("tsukiko"));
+const tools_1 = require("@kotori-bot/tools");
+const modules_1 = __importDefault(require("./modules"));
+const command_1 = __importDefault(require("./command"));
+const errror_1 = require("../utils/errror");
+const commandExtra_1 = __importDefault(require("../utils/commandExtra"));
+class Message extends modules_1.default {
+    midwareStack = [];
+    /* two commands data array kill them! */
+    commandStack = [];
+    regexpStack = [];
+    handleMessageEvent(session) {
+        /* Handle middle wares */
+        let isPass = true;
+        const midwareStack = Object.create(this.midwareStack);
+        let lastMidwareNum = -1;
+        while (midwareStack.length > 0) {
+            if (lastMidwareNum === midwareStack.length) {
+                isPass = false;
+                break;
+            }
+            lastMidwareNum = midwareStack.length;
+            session.quick(midwareStack[0].callback(() => midwareStack.shift(), session));
+        }
+        this.emit('midwares', { isPass, event: session });
+    }
+    async handleMidwaresEvent(session) {
+        const { isPass, event } = session;
+        event.api.adapter.status.receivedMsg += 1;
+        if (!isPass)
+            return;
+        /* Handle regexp */
+        this.regexpStack.forEach(element => {
+            const match = event.message.match(element.match);
+            if (!match)
+                return;
+            event.quick(element.callback(match, event));
+        });
+        /* Handle command */
+        const params = [event.message, event.api.adapter.config['command-prefix']];
+        if (!params[0].startsWith(params[1]))
+            return;
+        const commonParams = {
+            event,
+            command: (0, tools_1.stringRightSplit)(params[0], params[1]),
+        };
+        this.emit('before_parse', commonParams);
+        let isCancel = false;
+        const cancel = () => {
+            isCancel = true;
+        };
+        const commandParams = {
+            scope: event.type === 'group_msg' ? 'group' : 'private',
+            access: event.userId === event.api.adapter.config.master ? 2 /* CommandAccess.ADMIN */ : 0 /* CommandAccess.MEMBER */,
+        };
+        this.emit('before_command', { cancel, ...commonParams, ...commandParams });
+        if (isCancel)
+            return;
+        try {
+            command_1.default.parse(commonParams.command);
+        }
+        catch (err) {
+            if (!(err instanceof errror_1.CommandError) || !(err.extra instanceof commandExtra_1.default))
+                throw err;
+            const parseResult = err.extra.value;
+            const isSuccessParsed = parseResult.type === 'parsed';
+            this.emit('parse', { result: parseResult, ...commonParams, cancel });
+            if (isCancel)
+                return;
+            if (!isSuccessParsed)
+                throw err;
+            try {
+                const executedResult = await parseResult.action({ args: parseResult.args, options: parseResult.options }, event);
+                if (tsukiko_1.default.Object({}).index(tsukiko_1.default.Unknown()).check(executedResult)) {
+                    this.emit('command', { result: executedResult, ...commonParams, ...commandParams });
+                    return;
+                }
+                const objectTemp = (obj) => {
+                    const result = obj;
+                    Object.keys(result).forEach(key => {
+                        if (!result[key] || typeof result[key] !== 'string')
+                            return;
+                        result[key] = event.locale(result[key]);
+                    });
+                    return result;
+                };
+                const returnHandle = Array.isArray(executedResult)
+                    ? (0, tools_1.stringTemp)(event.locale(executedResult[0]), objectTemp(executedResult[1]))
+                    : event.locale(executedResult ?? '');
+                this.emit('command', {
+                    result: { type: 'success', return: returnHandle ?? undefined },
+                    ...commonParams,
+                    ...commandParams,
+                });
+                if (returnHandle)
+                    event.send(returnHandle);
+            }
+            catch (executeErr) {
+                this.emit('command', {
+                    result: { type: 'error', error: executeErr },
+                    ...commonParams,
+                    ...commandParams,
+                });
+            }
+        }
+    }
+    handleUnloadModuleEvent(session) {
+        if (!session.module)
+            return;
+        const superArr = [...this.midwareStack, ...this.commandStack, ...this.regexpStack];
+        Object.keys(superArr).forEach(indexTemp => {
+            if (!session.module)
+                return;
+            const index = parseInt(indexTemp, 10);
+            const element = superArr[index];
+            if (element.extend === session.module.mainPath)
+                delete superArr[index];
+        });
+    }
+    registeMessageEvent() {
+        this.on('midwares', session => this.handleMidwaresEvent(session));
+        this.on('group_msg', session => this.handleMessageEvent(session));
+        this.on('private_msg', session => this.handleMessageEvent(session));
+        this.before('send', session => {
+            const { api } = session;
+            api.adapter.status.sentMsg += 1;
+        });
+        this.on('unload_module', session => this.handleUnloadModuleEvent(session));
+    }
+    midware(callback, priority = 100) {
+        if (this.midwareStack.filter(Element => Element.callback === callback).length)
+            return false;
+        this.midwareStack.push({ callback, priority, extend: this.getCurrent() });
+        this.midwareStack.sort((first, second) => first.priority - second.priority);
+        return true;
+    }
+    command(template, config) {
+        const result = new command_1.default(template, config);
+        this.commandStack.push({
+            extend: this.getCurrent(),
+            data: command_1.default.dataList[command_1.default.dataList.length - 1],
+        });
+        return result;
+    }
+    regexp(match, callback) {
+        if (this.regexpStack.filter(Element => Element.match === match).length)
+            return false;
+        this.regexpStack.push({ extend: this.getCurrent(), match, callback });
+        return true;
+    }
+    boardcast(type, message) {
+        const send = type === 'private'
+            ? (api) => api.send_private_msg(message, 1)
+            : (api) => api.send_group_msg(message, 1);
+        /* this need support of database... */
+        Object.values(this.botStack).forEach(apis => {
+            /* feating... */
+            apis.forEach(api => send(api));
+        });
+    }
+    notify(message) {
+        const mainAdapterIdentity = Object.keys(this.config.adapter)[0];
+        Object.values(this.botStack).forEach(apis => apis.forEach(api => {
+            if (api.adapter.identity !== mainAdapterIdentity)
+                return;
+            api.send_private_msg(message, api.adapter.config.master);
+        }));
+    }
+}
+exports.Message = Message;
+exports.default = Message;

package/lib/base/modules.d.ts

@@ -0,0 +1,15 @@
+import Events from './events';
+import Context from '../context';
+import { type ModuleData, type ModuleInstanceConstructor, type ModuleInstanceFunction } from '../types';
+export declare class Modules extends Events {
+    private current;
+    private failedLoadCount;
+    protected getCurrent(): string;
+    private setCureent;
+    private runInstance;
+    private moduleAllHandle;
+    protected readonly moduleStack: ModuleData[];
+    use(summary: string | ModuleData | ModuleInstanceFunction | ModuleInstanceConstructor, ctx: Context, config: object): Promise<void>;
+    dispose(module: string | ModuleData): void;
+}
+export default Modules;

package/lib/base/modules.js

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Modules = void 0;
+const tools_1 = require("@kotori-bot/tools");
+const fs_1 = __importDefault(require("fs"));
+const tsukiko_1 = __importStar(require("tsukiko"));
+const path_1 = require("path");
+const events_1 = __importDefault(require("./events"));
+const adapter_1 = __importDefault(require("../components/adapter"));
+const errror_1 = require("../utils/errror");
+const consts_1 = require("../consts");
+function getTypeInfo(Instance, moduleName) {
+    let type = 'plugin';
+    let instanceType = 'none';
+    if ((0, tools_1.isClass)(Instance)) {
+        instanceType = 'constructor';
+        const func = (Obj) => adapter_1.default.isPrototypeOf.call(adapter_1.default, Obj);
+        const adapterName = moduleName.split(consts_1.ADAPTER_PREFIX)[1];
+        if (adapterName && func(Instance)) {
+            type = 'adapter';
+            return { type, instanceType, moduleName, adapterName };
+        }
+    }
+    else if (Instance instanceof Function) {
+        instanceType = 'function';
+        return { type, instanceType, moduleName };
+    }
+    return { type, instanceType, moduleName };
+}
+class Modules extends events_1.default {
+    current = 'core';
+    failedLoadCount = 0;
+    getCurrent() {
+        return this.current;
+    }
+    setCureent(value) {
+        const defaultValue = 'core';
+        return new Promise((resolve, reject) => {
+            if (!value) {
+                this.current = defaultValue;
+                resolve(null);
+                return;
+            }
+            const failTime = setTimeout(() => {
+                clearTimeout(failTime);
+                clearInterval(sleepTime);
+                reject(new errror_1.ModuleError(`Module loading timeout ${value}`));
+            }, consts_1.LOAD_MODULE_MAX_TIME);
+            const sleepTime = setInterval(() => {
+                if (this.current === defaultValue) {
+                    this.current = value;
+                    clearTimeout(failTime);
+                    clearInterval(sleepTime);
+                    resolve(null);
+                }
+            }, consts_1.LOAD_MODULE_SLEEP_TIME);
+        });
+    }
+    runInstance(typeInfo, Instances, data) {
+        /* before handle */
+        if (data.langDir)
+            data.ctx.i18n.use(typeof data.langDir === 'string' ? (0, path_1.resolve)(data.langDir) : (0, path_1.resolve)(...data.langDir)); /* here need */
+        /* after handle */
+        if (typeInfo.type === 'adapter') {
+            this.adapterStack[typeInfo.adapterName] = [Instances[0], Instances[1]];
+            return;
+        }
+        if (typeInfo.instanceType === 'none')
+            return;
+        /* Check config */
+        const isSchema = Instances[1]?.parseSafe(data.config);
+        if (isSchema && !isSchema.value) {
+            throw new errror_1.ModuleError(`Config format of module ${typeInfo.moduleName} is error`);
+        }
+        if (typeInfo.instanceType === 'constructor') {
+            (0, tools_1.none)(new Instances[0](data.ctx, data.config));
+            return;
+        }
+        Instances[0](data.ctx, data.config);
+    }
+    moduleAllHandle() {
+        this.emit('load_all_module', {
+            reality: this.moduleStack.length - this.failedLoadCount,
+            expected: this.moduleStack.length,
+        });
+    }
+    moduleStack = [];
+    async use(summary, ctx, config) {
+        const isString = typeof summary === 'string';
+        const isFunc = summary instanceof Function;
+        let Instance;
+        let typeInfo;
+        let exportObj;
+        const isLast = !isString && !isFunc && summary === this.moduleStack[this.moduleStack.length - 1];
+        try {
+            if (isFunc) {
+                typeInfo = getTypeInfo(summary, '');
+                Instance = summary;
+                exportObj = null;
+            }
+            else {
+                const moduleName = isString ? summary : summary.package.name;
+                const modulePath = `file://${isString ? summary : summary.mainPath}`;
+                if (isString && !fs_1.default.existsSync(summary))
+                    throw new errror_1.ModuleError(`Cannot find ${modulePath}`);
+                await this.setCureent(modulePath);
+                exportObj = await import(modulePath);
+                if (!tsukiko_1.default.Object({}).index(tsukiko_1.default.Unknown()).check(exportObj)) {
+                    throw new errror_1.DevError(`Not a valid module at ${modulePath}`);
+                }
+                exportObj = tsukiko_1.default.Object({}).index(tsukiko_1.default.Unknown()).check(exportObj.default) ? exportObj.default : exportObj;
+                if (exportObj.default instanceof Function) {
+                    typeInfo = getTypeInfo(exportObj.default, moduleName);
+                    Instance = exportObj.default;
+                }
+                else if (exportObj.main instanceof Function && !(0, tools_1.isClass)(exportObj.main)) {
+                    typeInfo = getTypeInfo(exportObj.main, moduleName);
+                    Instance = exportObj.main;
+                    if (typeInfo.instanceType !== 'function') {
+                        throw new errror_1.DevError(`Module instance is function,export name should be 'main' at ${modulePath}`);
+                    }
+                }
+                else if (exportObj.Main instanceof Function && (0, tools_1.isClass)(exportObj.Main)) {
+                    typeInfo = getTypeInfo(exportObj.Main, moduleName);
+                    Instance = exportObj.Main;
+                    if (typeInfo.instanceType !== 'constructor') {
+                        throw new errror_1.DevError(`Module instance is constructor,export name should be 'Main' at ${modulePath}`);
+                    }
+                }
+                else {
+                    typeInfo = getTypeInfo(null, moduleName);
+                    Instance = null;
+                }
+            }
+            const schema = exportObj && exportObj.config instanceof tsukiko_1.Parser ? exportObj.config : undefined;
+            this.runInstance(typeInfo, [Instance, schema], {
+                /* wait for logger updated after hered need new 功能 about print module of name */
+                /* Object.assign(ctx, {
+                    logger: ctx.logger.tag(stringRightSplit(typeInfo.moduleName, PLUGIN_PREFIX), 'italic', 'white'),
+                  }) */ ctx,
+                config,
+                langDir: exportObj && (typeof exportObj.lang === 'string' || Array.isArray(exportObj.lang))
+                    ? exportObj.lang
+                    : undefined,
+            });
+        }
+        catch (err) {
+            this.setCureent();
+            this.failedLoadCount += 1;
+            if (isLast)
+                this.moduleAllHandle();
+            throw err;
+        }
+        this.setCureent();
+        this.emit('load_module', {
+            module: isString || isFunc ? null : summary,
+            moduleType: typeInfo.type,
+            instanceType: typeInfo.instanceType,
+        });
+        if (isLast)
+            this.moduleAllHandle();
+    }
+    dispose(module) {
+        /* need more... */
+        const isString = typeof module === 'string';
+        const modulePath = isString ? module : module.mainPath;
+        this.emit('unload_module', { module: isString ? null : module });
+        if (!isString) {
+            module.fileList.forEach(file => delete require.cache[require.resolve(file)]);
+            for (let index = 0; index < this.moduleStack.length; index += 1) {
+                if (this.moduleStack[index] === module)
+                    delete this.moduleStack[index];
+            }
+        }
+        delete require.cache[require.resolve(modulePath)];
+    }
+}
+exports.Modules = Modules;
+exports.default = Modules;

package/lib/components/adapter.d.ts

@@ -0,0 +1,38 @@
+import type Api from './api';
+import type Context from '../context';
+import type { EventDataApiBase, AdapterConfig, EventType, EventDataTargetId, ApiConstructor, ElementsParam, MessageScope } from '../types';
+import Service from './service';
+interface Status {
+    value: 'online' | 'offline';
+    createTime: Date;
+    lastMsgTime: Date | null;
+    receivedMsg: number;
+    sentMsg: number;
+    offlineTimes: number;
+}
+interface AdapterImpl<T extends Api> {
+    readonly platform: string;
+    readonly selfId: EventDataTargetId;
+    readonly identity: string;
+    readonly api: T;
+    readonly status: Status;
+}
+export declare function ApiProxy<T extends Api>(api: T, ctx: Context): T;
+type EventApiType = {
+    [K in Extract<EventType[keyof EventType], EventDataApiBase<keyof EventType, MessageScope>>['type']]: EventType[K];
+};
+export declare abstract class Adapter<T extends Api = Api> extends Service implements AdapterImpl<T> {
+    constructor(ctx: Context, config: AdapterConfig, identity: string, ApiConstructor: ApiConstructor<T>, el?: ElementsParam);
+    abstract send(action: string, params?: object): void | object | Promise<unknown> | null | undefined;
+    protected online(): void;
+    protected offline(): void;
+    protected emit<N extends keyof EventApiType>(type: N, data: Omit<EventApiType[N], 'type' | 'api' | 'send' | 'locale' | 'quick' | 'error' | 'el' | 'messageType'>): void;
+    readonly ctx: Context;
+    readonly config: AdapterConfig;
+    readonly identity: string;
+    readonly platform: string;
+    readonly api: T;
+    readonly status: Status;
+    selfId: EventDataTargetId;
+}
+export default Adapter;

package/lib/components/adapter.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Adapter = exports.ApiProxy = void 0;
+const tools_1 = require("@kotori-bot/tools");
+const service_1 = __importDefault(require("./service"));
+const elements_1 = __importDefault(require("./elements"));
+// type AdapterSend = (...args: any[]) => void;
+function ApiProxy(api, ctx) {
+    const apiProxy = Object.create(api);
+    apiProxy.send_private_msg = new Proxy(api.send_private_msg, {
+        apply(_, __, argArray) {
+            const { '0': message, '1': targetId } = argArray;
+            let isCancel = false;
+            const cancel = () => {
+                isCancel = true;
+            };
+            ctx.emit('before_send', { api, message, messageType: 'private', targetId, cancel });
+            if (isCancel)
+                return;
+            api.send_private_msg(message, targetId, argArray[2]);
+        },
+    });
+    apiProxy.send_group_msg = new Proxy(api.send_group_msg, {
+        apply(_, __, argArray) {
+            const { '0': message, '1': targetId } = argArray;
+            let isCancel = false;
+            const cancel = () => {
+                isCancel = true;
+            };
+            ctx.emit('before_send', { api, message, messageType: 'group', targetId, cancel });
+            if (isCancel)
+                return;
+            api.send_group_msg(message, targetId, argArray[2]);
+        },
+    });
+    return apiProxy;
+}
+exports.ApiProxy = ApiProxy;
+class Adapter extends service_1.default {
+    constructor(ctx, config, identity, ApiConstructor, el = {}) {
+        super();
+        this.config = config;
+        this.identity = identity;
+        this.platform = config.extends;
+        this.ctx = ctx;
+        this.api = ApiProxy(new ApiConstructor(this, new elements_1.default(el)), this.ctx);
+        if (!this.ctx.internal.getBots()[this.platform])
+            this.ctx.internal.setBots(this.platform, []);
+        this.ctx.internal.getBots()[this.platform].push(this.api);
+    }
+    online() {
+        if (this.status.value !== 'offline')
+            return;
+        if (this.status.offlineTimes <= 0) {
+            this.ctx.emit('ready', { adapter: this });
+        }
+        this.ctx.emit('online', { adapter: this });
+        this.status.value = 'online';
+    }
+    offline() {
+        if (this.status.value !== 'online')
+            return;
+        this.ctx.emit('offline', { adapter: this });
+        this.status.value = 'offline';
+        this.status.offlineTimes += 1;
+    }
+    emit(type, data) {
+        const messageType = type.includes('group') ? 'group' : 'private';
+        const send = (message) => {
+            if (messageType === 'group') {
+                this.api.send_group_msg(message, data.groupId, data.extra);
+            }
+            else {
+                this.api.send_private_msg(message, data.userId, data.extra);
+            }
+        };
+        const locale = (val) => this.ctx.i18n.locale(val, this.config.lang);
+        const quick = async (message) => {
+            const msg = await message;
+            if (!msg)
+                return;
+            if (typeof msg === 'string') {
+                send(locale(msg));
+                return;
+            }
+            const params = msg[1];
+            Object.keys(params).forEach(key => {
+                if (typeof params[key] !== 'string')
+                    return;
+                params[key] = locale(params[key]);
+            });
+            send((0, tools_1.stringTemp)(locale(msg[0]), params));
+        };
+        const error = (type, data) => ({
+            type,
+            ...data,
+        });
+        this.ctx.emit(type, {
+            ...data,
+            api: this.api,
+            send,
+            locale,
+            quick,
+            error,
+            el: this.api.elements,
+            messageType,
+        });
+    }
+    ctx;
+    config;
+    identity;
+    platform;
+    api;
+    status = {
+        value: 'offline',
+        createTime: new Date(),
+        lastMsgTime: null,
+        receivedMsg: 0,
+        sentMsg: 0,
+        offlineTimes: 0,
+    };
+    selfId = -1;
+}
+exports.Adapter = Adapter;
+exports.default = Adapter;

package/lib/components/api.d.ts

@@ -0,0 +1,35 @@
+import type Adapter from './adapter';
+import type { EventDataTargetId, MessageRaw } from '../types';
+import Elements from './elements';
+interface ApiImpl {
+    readonly adapter: Adapter<this>;
+    send_private_msg(message: MessageRaw, userId: EventDataTargetId): void;
+    send_group_msg(message: MessageRaw, groupId: EventDataTargetId): void;
+    delete_msg(messageId: EventDataTargetId): void;
+    set_group_name(groupId: EventDataTargetId, groupName: string): void;
+    set_group_avatar(groupId: EventDataTargetId, image: string): void;
+    set_group_admin(groupId: EventDataTargetId, userId: EventDataTargetId, enable: boolean): void;
+    set_group_card(groupId: EventDataTargetId, userId: EventDataTargetId, card: string): void;
+    set_group_ban(groupId: EventDataTargetId, userId?: EventDataTargetId, time?: number): void;
+    send_group_notice(groupId: EventDataTargetId, content: string, image?: string): void;
+    set_group_kick(groupId: EventDataTargetId, userId: EventDataTargetId): void;
+    set_group_leave(groupId: EventDataTargetId): void;
+    elements: Elements;
+}
+export declare abstract class Api implements ApiImpl {
+    readonly adapter: Adapter<this>;
+    elements: Elements;
+    constructor(adapter: Adapter, el: Elements);
+    send_private_msg(message: MessageRaw, userId: EventDataTargetId, extra?: unknown): void;
+    send_group_msg(message: MessageRaw, groupId: EventDataTargetId, extra?: unknown): void;
+    delete_msg(messageId: EventDataTargetId, extra?: unknown): void;
+    set_group_name(groupId: EventDataTargetId, groupName: string, extra?: unknown): void;
+    set_group_avatar(groupId: EventDataTargetId, image: string, extra?: unknown): void;
+    set_group_admin(groupId: EventDataTargetId, userId: EventDataTargetId, enable: boolean, extra?: unknown): void;
+    set_group_card(groupId: EventDataTargetId, userId: EventDataTargetId, card: string, extra?: unknown): void;
+    set_group_ban(groupId: EventDataTargetId, userId?: EventDataTargetId, time?: number, extra?: unknown): void;
+    send_group_notice(groupId: EventDataTargetId, content: string, image?: string, extra?: unknown): void;
+    set_group_kick(groupId: EventDataTargetId, userId: EventDataTargetId, extra?: unknown): void;
+    set_group_leave(groupId: EventDataTargetId, extra?: unknown): void;
+}
+export default Api;

package/lib/components/api.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Api = void 0;
+const tools_1 = require("@kotori-bot/tools");
+class Api {
+    adapter;
+    elements;
+    constructor(adapter, el) {
+        this.adapter = adapter;
+        this.elements = el;
+    }
+    send_private_msg(message, userId, extra) {
+        (0, tools_1.none)(this, message, userId, extra);
+    }
+    send_group_msg(message, groupId, extra) {
+        (0, tools_1.none)(this, message, groupId, extra, extra);
+    }
+    delete_msg(messageId, extra) {
+        (0, tools_1.none)(this, messageId, extra);
+    }
+    set_group_name(groupId, groupName, extra) {
+        (0, tools_1.none)(this, groupId, groupName, extra);
+    }
+    set_group_avatar(groupId, image, extra) {
+        (0, tools_1.none)(this, groupId, image, extra);
+    }
+    set_group_admin(groupId, userId, enable, extra) {
+        (0, tools_1.none)(this, groupId, userId, enable, extra);
+    }
+    set_group_card(groupId, userId, card, extra) {
+        (0, tools_1.none)(this, groupId, userId, card, extra);
+    }
+    set_group_ban(groupId, userId, time, extra) {
+        (0, tools_1.none)(this, groupId, userId, time, extra);
+    }
+    send_group_notice(groupId, content, image, extra) {
+        (0, tools_1.none)(this, groupId, content, image, extra);
+    }
+    set_group_kick(groupId, userId, extra) {
+        (0, tools_1.none)(this, groupId, userId, extra);
+    }
+    set_group_leave(groupId, extra) {
+        (0, tools_1.none)(this, groupId, groupId, extra);
+    }
+}
+exports.Api = Api;
+exports.default = Api;

package/lib/components/elements.d.ts

@@ -0,0 +1,12 @@
+import { ElementsParam, EventDataTargetId } from '../types';
+export declare class Elements {
+    constructor(data: ElementsParam);
+    at: (target: EventDataTargetId, extra?: unknown) => string;
+    image: (url: string, extra?: unknown) => string;
+    voice: (url: string, extra?: unknown) => string;
+    video: (url: string, extra?: unknown) => string;
+    face: (id: number | string, extra?: unknown) => string;
+    file: (data: ArrayBuffer, extra?: unknown) => string;
+    supports: string[];
+}
+export default Elements;