@kotori-bot/core 1.1.0

package/lib/components/elements.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Elements = void 0;
+const tools_1 = require("@kotori-bot/tools");
+const defaultMethod = (...args) => {
+    (0, tools_1.none)(...args);
+    return '';
+};
+class Elements {
+    constructor(data) {
+        this.at = data.at || defaultMethod;
+        this.image = data.image || defaultMethod;
+        this.voice = data.voice || defaultMethod;
+        this.video = data.video || defaultMethod;
+        this.face = data.face || defaultMethod;
+        this.file = data.file || defaultMethod;
+        this.supports = Object.keys(data);
+    }
+    at;
+    image;
+    voice;
+    video;
+    face;
+    file;
+    supports;
+}
+exports.Elements = Elements;
+exports.default = Elements;

package/lib/components/service.d.ts

@@ -0,0 +1,13 @@
+interface ServiceImpl {
+    readonly config: object;
+    handle(...data: unknown[]): void;
+    start(): void;
+    stop(): void;
+}
+export declare abstract class Service implements ServiceImpl {
+    abstract readonly config: object;
+    abstract handle(...data: unknown[]): void;
+    abstract start(): void;
+    abstract stop(): void;
+}
+export default Service;

package/lib/components/service.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Service = void 0;
+class Service {
+}
+exports.Service = Service;
+exports.default = Service;

package/lib/consts.d.ts

@@ -0,0 +1,11 @@
+import { LocaleType } from '@kotori-bot/i18n';
+export declare const OFFICIAL_MODULES_SCOPE = "@kotori-bot/";
+export declare const PLUGIN_PREFIX = "kotori-plugin-";
+export declare const ADAPTER_PREFIX = "kotori-plugin-adapter-";
+export declare const LOAD_MODULE_MAX_TIME: number;
+export declare const LOAD_MODULE_SLEEP_TIME = 150;
+export declare const DEFAULT_LANG: LocaleType;
+export declare const DEFAULT_ROOT_DIR = "./";
+export declare const DEFAULT_MODULES_DIR = "./modules";
+export declare const DEFAULT_COMMAND_PREFIX = "/";
+export declare const DEFAULT_ENV = "dev";

package/lib/consts.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ENV = exports.DEFAULT_COMMAND_PREFIX = exports.DEFAULT_MODULES_DIR = exports.DEFAULT_ROOT_DIR = exports.DEFAULT_LANG = exports.LOAD_MODULE_SLEEP_TIME = exports.LOAD_MODULE_MAX_TIME = exports.ADAPTER_PREFIX = exports.PLUGIN_PREFIX = exports.OFFICIAL_MODULES_SCOPE = void 0;
+exports.OFFICIAL_MODULES_SCOPE = '@kotori-bot/';
+exports.PLUGIN_PREFIX = 'kotori-plugin-';
+exports.ADAPTER_PREFIX = `${exports.PLUGIN_PREFIX}adapter-`;
+exports.LOAD_MODULE_MAX_TIME = 10 * 1000;
+exports.LOAD_MODULE_SLEEP_TIME = 150;
+exports.DEFAULT_LANG = 'en_US';
+exports.DEFAULT_ROOT_DIR = './';
+exports.DEFAULT_MODULES_DIR = './modules';
+exports.DEFAULT_COMMAND_PREFIX = '/';
+exports.DEFAULT_ENV = 'dev';

package/lib/context.d.ts

@@ -0,0 +1,13 @@
+import Logger from '@kotori-bot/logger';
+import { Http } from '@kotori-bot/tools';
+import Locale from './utils/i18n';
+import Internal from './base/internal';
+import { KotoriConfig } from './types';
+export declare class Context extends Internal {
+    http: Http;
+    logger: typeof Logger & typeof Logger.debug;
+    readonly i18n: Locale;
+    private initialize;
+    constructor(Config?: KotoriConfig);
+}
+export default Context;

package/lib/context.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const logger_1 = __importDefault(require("@kotori-bot/logger"));
+const tools_1 = require("@kotori-bot/tools");
+const i18n_1 = __importDefault(require("./utils/i18n"));
+const internal_1 = __importDefault(require("./base/internal"));
+class Context extends internal_1.default {
+    http = new tools_1.Http({ validateStatus: () => true });
+    logger = Object.assign(logger_1.default, new Proxy(logger_1.default.debug, {
+        apply: (target, _, argArray) => {
+            if (this.options.env === 'dev')
+                target(argArray);
+        },
+    }));
+    i18n;
+    initialize() {
+        this.registeMessageEvent();
+        this.midware((next, session) => {
+            const { selfId } = session.api.adapter;
+            if (session.userId !== selfId)
+                next();
+        }, 50);
+    }
+    constructor(Config) {
+        super(Config);
+        this.i18n = new i18n_1.default(this.config.global.lang);
+        this.initialize();
+    }
+}
+exports.Context = Context;
+exports.default = Context;

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+import Context from './context';
+export * from './components/adapter';
+export * from './components/api';
+export * from './components/elements';
+export * from './context';
+export * from './utils/errror';
+export * from './consts';
+export * from './types';
+export * from '@kotori-bot/tools';
+export * from 'tsukiko';
+export declare class ContextInstance {
+    protected constructor();
+    private static instance;
+    protected static setInstance(ctx: Context): void;
+    static getInstance(): Context;
+    static getMixin(): any;
+}

package/lib/index.js

@@ -0,0 +1,43 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextInstance = void 0;
+const tools_1 = require("@kotori-bot/tools");
+__exportStar(require("./components/adapter"), exports);
+__exportStar(require("./components/api"), exports);
+__exportStar(require("./components/elements"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./utils/errror"), exports);
+__exportStar(require("./consts"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("@kotori-bot/tools"), exports);
+__exportStar(require("tsukiko"), exports);
+class ContextInstance {
+    constructor() {
+        (0, tools_1.none)();
+    }
+    static instance = {};
+    static setInstance(ctx) {
+        this.instance = ctx;
+    }
+    static getInstance() {
+        return this.instance;
+    }
+    static getMixin() {
+        return Object.assign(ContextInstance.getInstance() /* , Context */);
+    }
+}
+exports.ContextInstance = ContextInstance;

package/lib/types.d.ts

@@ -0,0 +1,417 @@
+import type { StringTempArgs, obj } from '@kotori-bot/tools';
+import Tsu from 'tsukiko';
+import { LocaleType } from '@kotori-bot/i18n';
+import type Api from './components/api';
+import type Adapter from './components/adapter';
+import type Context from './context';
+import type Elements from './components/elements';
+export declare const baseDirSchema: import("tsukiko").ObjectParser<{
+    root: import("tsukiko").StringParser;
+    modules: import("tsukiko").StringParser;
+}>;
+export type BaseDir = Tsu.infer<typeof baseDirSchema>;
+export declare const packageInfoSchema: import("tsukiko").ObjectParser<{
+    name: import("tsukiko").StringParser;
+    version: import("tsukiko").StringParser;
+    description: import("tsukiko").StringParser;
+    main: import("tsukiko").StringParser;
+    license: import("tsukiko").LiteralParser<"GPL-3.0">;
+    author: import("tsukiko").StringParser;
+}>;
+export type PackageInfo = Tsu.infer<typeof packageInfoSchema>;
+export declare const localeTypeSchema: import("tsukiko").UnionParser<[import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"en_US">, import("tsukiko").LiteralParser<"ja_JP">]>, import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"zh_CN">, import("tsukiko").LiteralParser<"zh_TW">]>]>;
+export declare const globalOptions: import("tsukiko").ObjectParser<{
+    env: import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"dev">, import("tsukiko").LiteralParser<"build">]>;
+}>;
+export type GlobalOptions = Tsu.infer<typeof globalOptions>;
+declare const adapterConfigBaseSchema: import("tsukiko").IntersectionParser<[import("tsukiko").ObjectParser<{
+    extends: import("tsukiko").StringParser;
+    master: import("tsukiko").UnionParser<[import("tsukiko").NumberParser, import("tsukiko").StringParser]>;
+}>, import("tsukiko").ObjectParser<{
+    lang: import("tsukiko").UnionParser<[import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"en_US">, import("tsukiko").LiteralParser<"ja_JP">]>, import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"zh_CN">, import("tsukiko").LiteralParser<"zh_TW">]>]>;
+    'command-prefix': import("tsukiko").StringParser;
+}>]>;
+export declare const globalConfigSchemaController: (lang?: LocaleType, commandPrefix?: string) => import("tsukiko").ObjectParser<{
+    global: import("tsukiko").IntersectionParser<[import("tsukiko").ObjectParser<{
+        dirs: import("tsukiko").ArrayParser<import("tsukiko").StringParser>;
+    }>, import("tsukiko").ObjectParser<{
+        lang: import("tsukiko").UnionParser<[import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"en_US">, import("tsukiko").LiteralParser<"ja_JP">]>, import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"zh_CN">, import("tsukiko").LiteralParser<"zh_TW">]>]>;
+        'command-prefix': import("tsukiko").StringParser;
+    }>]>;
+    adapter: import("tsukiko").Parser<import("tsukiko").IndexObject<import("tsukiko").ObjectParserInfer<{
+        extends: import("tsukiko").StringParser;
+        master: import("tsukiko").UnionParser<[import("tsukiko").NumberParser, import("tsukiko").StringParser]>;
+    }> & import("tsukiko").ObjectParserInfer<{
+        lang: import("tsukiko").UnionParser<[import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"en_US">, import("tsukiko").LiteralParser<"ja_JP">]>, import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"zh_CN">, import("tsukiko").LiteralParser<"zh_TW">]>]>;
+        'command-prefix': import("tsukiko").StringParser;
+    }>>>;
+    plugin: import("tsukiko").Parser<import("tsukiko").IndexObject<import("tsukiko").ObjectParserInfer<{
+        priority: import("tsukiko").NumberParser;
+    }>>>;
+}>;
+declare const globalConfigSchema: import("tsukiko").ObjectParser<{
+    global: import("tsukiko").IntersectionParser<[import("tsukiko").ObjectParser<{
+        dirs: import("tsukiko").ArrayParser<import("tsukiko").StringParser>;
+    }>, import("tsukiko").ObjectParser<{
+        lang: import("tsukiko").UnionParser<[import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"en_US">, import("tsukiko").LiteralParser<"ja_JP">]>, import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"zh_CN">, import("tsukiko").LiteralParser<"zh_TW">]>]>;
+        'command-prefix': import("tsukiko").StringParser;
+    }>]>;
+    adapter: import("tsukiko").Parser<import("tsukiko").IndexObject<import("tsukiko").ObjectParserInfer<{
+        extends: import("tsukiko").StringParser;
+        master: import("tsukiko").UnionParser<[import("tsukiko").NumberParser, import("tsukiko").StringParser]>;
+    }> & import("tsukiko").ObjectParserInfer<{
+        lang: import("tsukiko").UnionParser<[import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"en_US">, import("tsukiko").LiteralParser<"ja_JP">]>, import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"zh_CN">, import("tsukiko").LiteralParser<"zh_TW">]>]>;
+        'command-prefix': import("tsukiko").StringParser;
+    }>>>;
+    plugin: import("tsukiko").Parser<import("tsukiko").IndexObject<import("tsukiko").ObjectParserInfer<{
+        priority: import("tsukiko").NumberParser;
+    }>>>;
+}>;
+export type GlobalConfig = Tsu.infer<typeof globalConfigSchema>;
+export type AdapterConfig = Tsu.infer<typeof adapterConfigBaseSchema>;
+export type AdapterConstructor = new (ctx: Context, config: AdapterConfig, identity: string) => Adapter;
+export type ApiConstructor<T extends Api> = new (adapter: Adapter, el: Elements) => T;
+export type ElementsParam = {
+    [K in Exclude<keyof Elements, 'supports'>]?: (...args: unknown[]) => string;
+};
+export declare const kotoriConfigSchema: import("tsukiko").ObjectParser<{
+    baseDir: import("tsukiko").ObjectParser<{
+        root: import("tsukiko").StringParser;
+        modules: import("tsukiko").StringParser;
+    }>;
+    config: import("tsukiko").ObjectParser<{
+        global: import("tsukiko").IntersectionParser<[import("tsukiko").ObjectParser<{
+            dirs: import("tsukiko").ArrayParser<import("tsukiko").StringParser>;
+        }>, import("tsukiko").ObjectParser<{
+            lang: import("tsukiko").UnionParser<[import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"en_US">, import("tsukiko").LiteralParser<"ja_JP">]>, import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"zh_CN">, import("tsukiko").LiteralParser<"zh_TW">]>]>;
+            'command-prefix': import("tsukiko").StringParser;
+        }>]>;
+        adapter: import("tsukiko").Parser<import("tsukiko").IndexObject<import("tsukiko").ObjectParserInfer<{
+            extends: import("tsukiko").StringParser;
+            master: import("tsukiko").UnionParser<[import("tsukiko").NumberParser, import("tsukiko").StringParser]>;
+        }> & import("tsukiko").ObjectParserInfer<{
+            lang: import("tsukiko").UnionParser<[import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"en_US">, import("tsukiko").LiteralParser<"ja_JP">]>, import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"zh_CN">, import("tsukiko").LiteralParser<"zh_TW">]>]>;
+            'command-prefix': import("tsukiko").StringParser;
+        }>>>;
+        plugin: import("tsukiko").Parser<import("tsukiko").IndexObject<import("tsukiko").ObjectParserInfer<{
+            priority: import("tsukiko").NumberParser;
+        }>>>;
+    }>;
+    options: import("tsukiko").ObjectParser<{
+        env: import("tsukiko").UnionParser<[import("tsukiko").LiteralParser<"dev">, import("tsukiko").LiteralParser<"build">]>;
+    }>;
+}>;
+export type KotoriConfig = Tsu.infer<typeof kotoriConfigSchema>;
+export interface ApiExtra {
+    default: {
+        type: 'default';
+    };
+}
+export declare const enum CommandAccess {
+    MEMBER = 0,
+    MANGER = 1,
+    ADMIN = 2
+}
+export type CommandAction = (data: {
+    args: CommandArgType[];
+    options: obj<CommandArgType>;
+}, session: EventType['group_msg' | 'private_msg']) => MessageQuick | CommandResultExtra[keyof CommandResultExtra] | void | Promise<MessageQuick | CommandResultExtra[keyof CommandResultExtra] | void>;
+export type CommandArgType = string | number;
+export type CommandArgTypeSign = 'string' | 'number';
+export interface CommandConfig {
+    alias?: string[];
+    scope?: MessageScope | 'all';
+    access?: CommandAccess;
+    help?: string;
+    action?: CommandAction;
+}
+export interface CommandArg {
+    name: string;
+    type: CommandArgTypeSign;
+    optional: boolean;
+    default?: CommandArgType;
+    rest: boolean;
+}
+export interface CommandOption {
+    name: string;
+    type: CommandArgTypeSign;
+    default?: CommandArgType;
+    realname: string;
+    description?: string;
+}
+export interface CommandData {
+    root: string;
+    alias: string[];
+    args: CommandArg[];
+    options: CommandOption[];
+    scope: CommandConfig['scope'];
+    access: CommandAccess;
+    help?: string;
+    action?: CommandAction;
+    description?: string;
+}
+export interface CommandParseResult {
+    parsed: {
+        action: CommandAction;
+        args: CommandArgType[];
+        options: obj<CommandArgType>;
+    };
+    option_error: {
+        expected: string;
+        reality: string;
+        target: string;
+    };
+    arg_many: {
+        expected: number;
+        reality: number;
+    };
+    arg_few: CommandParseResult['arg_many'];
+    arg_error: CommandParseResult['option_error'];
+    syntax: {
+        index: number;
+        char: string;
+    };
+    unknown: {
+        input: string;
+    };
+}
+export interface CommandResult extends CommandParseResult {
+    success: {
+        return?: string;
+    };
+    error: {
+        error: unknown;
+    };
+}
+export type CommandParseResultExtra = Pick<CommandResultExtra, keyof CommandParseResult>;
+export type CommandExecuteResultExtra = Pick<CommandResultExtra, Exclude<keyof CommandResult, keyof CommandParseResult>>;
+export type CommandResultExtra = {
+    [K in keyof CommandResult]: {
+        type: K;
+    } & CommandResult[K];
+};
+export type MessageRaw = string;
+export type MessageScope = 'private' | 'group';
+export type MessageQuickFunc = (msg: MessageQuick) => void;
+export type MessageQuickReal = MessageRaw | [string, StringTempArgs] | void;
+export type MessageQuick = MessageQuickReal | Promise<MessageQuickReal>;
+export type ModuleType = 'database' | 'adapter' | 'plugin';
+export type ModuleInstanceType = 'constructor' | 'function' | 'none';
+export type ModuleInstanceConstructor = new (ctx: Context, config: object) => unknown;
+export type ModuleInstanceFunction = (ctx: Context, config: object) => unknown;
+export type MidwareCallback = (next: () => void, session: EventDataMsg) => MessageQuick;
+export type RegexpCallback = (match: RegExpMatchArray, session: EventDataMsg) => MessageQuick;
+export interface MidwareStack {
+    extend: string;
+    callback: MidwareCallback;
+    priority: number;
+}
+export interface CommandStack {
+    extend: string;
+    data: CommandData;
+}
+export interface RegexpStack {
+    extend: string;
+    match: RegExp;
+    callback: RegexpCallback;
+}
+export declare const ModulePackageSchema: import("tsukiko").ObjectParser<{
+    name: import("tsukiko").StringParser;
+    version: import("tsukiko").StringParser;
+    description: import("tsukiko").StringParser;
+    main: import("tsukiko").StringParser;
+    license: import("tsukiko").LiteralParser<"GPL-3.0">;
+    author: import("tsukiko").UnionParser<[import("tsukiko").StringParser, import("tsukiko").ArrayParser<import("tsukiko").StringParser>]>;
+    peerDependencies: import("tsukiko").ObjectParser<{
+        'kotori-bot': import("tsukiko").StringParser;
+    }>;
+}>;
+export type ModulePackage = Tsu.infer<typeof ModulePackageSchema>;
+export interface ModuleData {
+    package: ModulePackage;
+    fileList: string[];
+    mainPath: string;
+}
+export interface EventDataBase<T extends keyof EventType> {
+    type: T;
+}
+interface EventDataLoadModule extends EventDataBase<'load_module'> {
+    module: ModuleData | null;
+    moduleType: ModuleType;
+    instanceType: ModuleInstanceType;
+}
+interface EventDataLoadAllModule extends EventDataBase<'load_all_module'> {
+    reality: number;
+    expected: number;
+}
+interface EventDataUnloadModule extends EventDataBase<'unload_module'> {
+    module: ModuleData | null;
+}
+type EventDataMsgSenderSex = 'male' | 'female' | 'unknown';
+type EventDataOperation = 'set' | 'unset';
+export interface EventDataMsgSender {
+    nickname: string;
+    sex: EventDataMsgSenderSex;
+    age: number;
+}
+export interface EventDataAdapterBase<T extends keyof EventType> extends EventDataBase<T> {
+    adapter: Adapter;
+}
+interface EventDataConnect extends EventDataAdapterBase<'connect'> {
+    normal: boolean;
+    info: string;
+    onlyStart?: boolean;
+}
+interface EventDataDisconnect extends EventDataAdapterBase<'disconnect'> {
+    normal: boolean;
+    info: string;
+}
+interface EventDataReady extends EventDataAdapterBase<'ready'> {
+}
+interface EventDataOnline extends EventDataAdapterBase<'online'> {
+}
+interface EventDataOffline extends EventDataAdapterBase<'offline'> {
+}
+export type EventDataMsg = EventDataPrivateMsg | EventDataGroupMsg;
+interface EventDataMidwares extends EventDataBase<'midwares'> {
+    isPass: boolean;
+    event: EventDataMsg;
+}
+interface EventDataBeforeParse extends EventDataBase<'before_parse'> {
+    event: EventDataMsg;
+    command: string;
+}
+interface EventDataParse extends EventDataBase<'parse'> {
+    event: EventDataMsg;
+    command: string;
+    result: CommandParseResultExtra[keyof CommandParseResultExtra];
+    cancel(): void;
+}
+interface EventDataBeforeCommand extends EventDataBase<'before_command'> {
+    event: EventDataMsg;
+    command: string;
+    scope: MessageScope;
+    access: CommandAccess;
+    cancel(): void;
+}
+interface EventDataCommand extends EventDataBase<'command'> {
+    event: EventDataMsg;
+    command: string;
+    scope: MessageScope;
+    access: CommandAccess;
+    result: CommandResultExtra[keyof CommandResultExtra];
+}
+export declare const eventDataTargetIdSchema: import("tsukiko").UnionParser<[import("tsukiko").StringParser, import("tsukiko").NumberParser]>;
+export type EventDataTargetId = Tsu.infer<typeof eventDataTargetIdSchema>;
+interface EventDataBeforeSend extends EventDataBase<'before_send'> {
+    api: Api;
+    message: MessageRaw;
+    messageType: MessageScope;
+    targetId: EventDataTargetId;
+    cancel(): void;
+}
+interface EventDataSend extends EventDataBase<'send'> {
+    api: Api;
+    messageId: EventDataTargetId;
+}
+export interface EventDataApiBase<T extends keyof EventType, M extends MessageScope = MessageScope> extends EventDataBase<T> {
+    api: Api;
+    el: Elements;
+    userId: EventDataTargetId;
+    messageType: M;
+    send(message: MessageRaw): void;
+    locale(val: string): string;
+    quick(message: MessageQuick): void;
+    error<T extends keyof CommandResult>(type: T, data?: Omit<CommandResultExtra[T], 'type'>): CommandResultExtra[T];
+    extra?: unknown;
+}
+interface EventDataPrivateMsg extends EventDataApiBase<'private_msg', 'private'> {
+    messageId: EventDataTargetId;
+    message: MessageRaw;
+    sender: EventDataMsgSender;
+    groupId?: EventDataTargetId;
+}
+interface EventDataGroupMsg extends EventDataApiBase<'group_msg', 'group'> {
+    messageId: EventDataTargetId;
+    message: MessageRaw;
+    sender: EventDataMsgSender;
+    groupId: EventDataTargetId;
+}
+interface EventDataPrivateRecall extends EventDataApiBase<'private_recall', 'private'> {
+    messageId: EventDataTargetId;
+}
+interface EventDataGroupRecall extends EventDataApiBase<'group_recall', 'group'> {
+    messageId: EventDataTargetId;
+    operatorId: EventDataTargetId;
+    groupId: EventDataTargetId;
+}
+interface EventDataPrivateRequest extends EventDataApiBase<'private_request', 'private'> {
+    userId: EventDataTargetId;
+}
+interface EventDataGroupRequest extends EventDataApiBase<'group_request', 'group'> {
+    userId: EventDataTargetId;
+    operatorId: EventDataTargetId;
+    groupId: EventDataTargetId;
+}
+interface EventDataPrivateAdd extends EventDataApiBase<'private_add', 'private'> {
+    userId: EventDataTargetId;
+}
+interface EventDataGroupIncrease extends EventDataApiBase<'group_increase', 'group'> {
+    userId: EventDataTargetId;
+    operatorId: EventDataTargetId;
+    groupId: EventDataTargetId;
+}
+interface EventDataGroupDecrease extends EventDataApiBase<'group_decrease', 'group'> {
+    userId: EventDataTargetId;
+    operatorId: EventDataTargetId;
+    groupId: EventDataTargetId;
+}
+interface EventDataGroupAdmin extends EventDataApiBase<'group_admin', 'group'> {
+    userId: EventDataTargetId;
+    operation: EventDataOperation;
+    groupId: EventDataTargetId;
+}
+interface EventDataGroupBan extends EventDataApiBase<'group_ban', 'group'> {
+    userId: EventDataTargetId | 0;
+    operatorId?: EventDataTargetId;
+    time?: number | -1;
+    groupId: EventDataTargetId;
+}
+export interface EventType {
+    load_module: EventDataLoadModule;
+    load_all_module: EventDataLoadAllModule;
+    unload_module: EventDataUnloadModule;
+    connect: EventDataConnect;
+    disconnect: EventDataDisconnect;
+    ready: EventDataReady;
+    online: EventDataOnline;
+    offline: EventDataOffline;
+    midwares: EventDataMidwares;
+    before_parse: EventDataBeforeParse;
+    parse: EventDataParse;
+    before_command: EventDataBeforeCommand;
+    command: EventDataCommand;
+    before_send: EventDataBeforeSend;
+    send: EventDataSend;
+    private_msg: EventDataPrivateMsg;
+    group_msg: EventDataGroupMsg;
+    private_recall: EventDataPrivateRecall;
+    group_recall: EventDataGroupRecall;
+    private_request: EventDataPrivateRequest;
+    group_request: EventDataGroupRequest;
+    private_add: EventDataPrivateAdd;
+    group_increase: EventDataGroupIncrease;
+    group_decrease: EventDataGroupDecrease;
+    group_admin: EventDataGroupAdmin;
+    group_ban: EventDataGroupBan;
+}
+export type EventCallback<T extends keyof EventType> = (data: EventType[T]) => void;
+export type EventLists = {
+    type: keyof EventType;
+    callback: EventCallback<keyof EventType>;
+}[];
+export interface DevErrorExtra {
+    path: string;
+    type: 'warning' | 'info' | 'error';
+}
+export {};