floating-live 0.15.11 → 0.16.0-alpha.1

package/dist/live/room.d.ts

@@ -0,0 +1,150 @@
+import { CustomEventEmitter } from "../utils/EventEmitter";
+import { LiveMessage } from "./message";
+import { UserInfo } from "./messageInfo";
+export declare abstract class LiveRoom extends CustomEventEmitter implements LiveRoomData {
+    constructor();
+    /** 平台 */
+    abstract readonly platform: string;
+    /** 房间id */
+    abstract readonly id: string | number;
+    /** 房间详情 */
+    abstract detail: LiveRoomDetailInfo;
+    /** 统计信息 */
+    stats?: LiveRoomStatsInfo;
+    /** 主播信息 */
+    abstract anchor: UserInfo;
+    /** 直播状态 */
+    status: LiveRoomStatus;
+    /** 时间戳 */
+    timestamp: number;
+    /** 当前直播id */
+    liveId?: string;
+    /** 房间是否打开 */
+    opened: boolean;
+    /** 是否连接上房间 */
+    connection: LiveConnectionStatus;
+    /** 房间是否可用 */
+    abstract available: boolean;
+    /** 打开连接 */
+    abstract open(): void;
+    /** 关闭连接 */
+    abstract close(): void;
+    /** 从服务器获取信息 */
+    abstract getInfo(): Promise<void>;
+    /** 销毁事件 */
+    protected onDestroy?(): void;
+    /** 销毁 */
+    destroy(): void;
+    protected emitMessage(msg: LiveMessage.All): void;
+    /** 发送源消息 */
+    protected emitRaw(msg: any): void;
+    /** 获取数据 */
+    toData(): LiveRoomData;
+    get key(): string;
+    on<K extends keyof LiveRoomEventMap>(type: K, listener: (e: LiveRoomEventMap[K]) => void): void;
+    once<K extends keyof LiveRoomEventMap>(type: K, listener: (e: LiveRoomEventMap[K]) => void): void;
+    off<K extends keyof LiveRoomEventMap>(type: K, listener: (e: LiveRoomEventMap[K]) => void): void;
+    emit<K extends keyof LiveRoomEventMap>(type: LiveRoomEventMap[K] extends Record<string, never> ? K : never): void;
+    emit<K extends keyof LiveRoomEventMap>(type: K, detail: LiveRoomEventMap[K]): void;
+}
+/** 房间数据 */
+export interface LiveRoomData {
+    /** 平台id */
+    platform: string;
+    /** 房间id */
+    id: number | string;
+    /** 房间key */
+    key: string;
+    /** 基本信息 */
+    detail: LiveRoomDetailInfo;
+    /** 统计信息 */
+    stats?: LiveRoomStatsInfo;
+    /** 主播信息 */
+    anchor: UserInfo;
+    /** 时间戳 */
+    timestamp: number;
+    /** 当前直播id */
+    liveId?: string;
+    /** 直播状态 */
+    status: LiveRoomStatus;
+    /** 直播间是否可用 */
+    available: boolean;
+    /** 房间监听是否打开 */
+    opened: boolean;
+    /** 房间连接状态 */
+    connection: LiveConnectionStatus;
+}
+/** 房间展示信息 */
+export interface LiveRoomDetailInfo {
+    /** 直播标题 */
+    title?: string;
+    /** 分区 */
+    area?: string[];
+    /** 封面 */
+    cover?: string;
+}
+/** 房间统计数据信息 */
+export interface LiveRoomStatsInfo {
+    /** 点赞数 */
+    like?: number;
+    /** 观看数 */
+    view?: number;
+    /** 在线人数 */
+    online?: number;
+    /** 人气值 */
+    popularity?: number;
+}
+/** 直播间状态 */
+export declare enum LiveRoomStatus {
+    /** 未开播 */
+    off = 0,
+    /** 正在直播 */
+    live = 1,
+    /** 正在轮播 */
+    round = 2,
+    /** 被封禁 */
+    banned = -1,
+    /** 已上锁 */
+    locked = -2
+}
+/** 直播间状态 */
+export declare enum LiveConnectionStatus {
+    /** 未连接 */
+    off = 0,
+    /** 连接中 */
+    connecting = 1,
+    /** 连接到服务器 */
+    connected = 2,
+    /** 连接到房间 */
+    entered = 3,
+    /** 连接失败或断开 */
+    disconnected = -1
+}
+export interface LiveRoomEventMap {
+    status: {
+        status: LiveRoomStatus;
+        timestamp: number;
+        liveId?: string | number;
+    };
+    update: {};
+    detail: {
+        detail: Partial<LiveRoomDetailInfo>;
+    };
+    stats: {
+        stats: LiveRoomStatsInfo;
+    };
+    message: {
+        message: LiveMessage.All;
+    };
+    raw: {
+        platform: string;
+        roomId: string | number;
+        data: any;
+    };
+    connecting: {};
+    connected: {};
+    disconnect: {};
+    enter: {};
+    open: {};
+    close: {};
+}

package/dist/live/room.js

@@ -0,0 +1,120 @@
+import { CustomEventEmitter } from "../utils/EventEmitter";
+export class LiveRoom extends CustomEventEmitter {
+    constructor() {
+        super();
+        /** 直播状态 */
+        this.status = LiveRoomStatus.off;
+        /** 时间戳 */
+        this.timestamp = 0;
+        /** 房间是否打开 */
+        this.opened = false;
+        /** 是否连接上房间 */
+        this.connection = LiveConnectionStatus.off;
+    }
+    /** 销毁 */
+    destroy() {
+        this.close();
+        this.onDestroy?.();
+    }
+    // 发送消息
+    emitMessage(msg) {
+        // 其他消息 => 先更改状态再发送消息
+        // 直播结束消息 => 先发送消息再更改状态
+        switch (msg.type) {
+            case "live_start":
+                this.status = LiveRoomStatus.live;
+                this.timestamp = msg.timestamp;
+                this.emit("status", {
+                    status: LiveRoomStatus.live,
+                    timestamp: msg.timestamp,
+                    liveId: msg.info.id,
+                });
+                break;
+            case "live_detail":
+                this.detail = Object.assign(this.detail, msg.info);
+                this.emit("detail", { detail: msg.info });
+                break;
+            case "live_stats":
+                this.stats = Object.assign(this.stats, msg.info);
+                this.emit("stats", { stats: msg.info });
+                break;
+            case "live_end":
+            case "live_cut":
+                this.status = msg.status || LiveRoomStatus.off;
+                this.timestamp = msg.timestamp;
+                this.emit("message", { message: msg });
+                this.emit("status", {
+                    status: msg.status || LiveRoomStatus.off,
+                    timestamp: msg.timestamp,
+                    liveId: this.liveId,
+                });
+                return;
+        }
+        this.emit("message", { message: msg });
+    }
+    /** 发送源消息 */
+    emitRaw(msg) {
+        this.emit("raw", { platform: this.platform, roomId: this.id, data: msg });
+    }
+    /** 获取数据 */
+    toData() {
+        return {
+            platform: this.platform,
+            id: this.id,
+            detail: this.detail,
+            stats: this.stats,
+            anchor: this.anchor,
+            timestamp: this.timestamp,
+            status: this.status,
+            liveId: this.liveId,
+            available: this.available,
+            opened: this.opened,
+            connection: this.connection,
+            key: this.key,
+        };
+    }
+    get key() {
+        return `${this.platform}:${this.id}`;
+    }
+    on(type, listener) {
+        super.on(type, listener);
+    }
+    once(type, listener) {
+        super.once(type, listener);
+        this.emit("connecting");
+    }
+    off(type, listener) {
+        super.off(type, listener);
+    }
+    emit(type, detail) {
+        super.emit(type, detail);
+    }
+}
+/** 直播间状态 */
+export var LiveRoomStatus;
+(function (LiveRoomStatus) {
+    /** 未开播 */
+    LiveRoomStatus[LiveRoomStatus["off"] = 0] = "off";
+    /** 正在直播 */
+    LiveRoomStatus[LiveRoomStatus["live"] = 1] = "live";
+    /** 正在轮播 */
+    LiveRoomStatus[LiveRoomStatus["round"] = 2] = "round";
+    /** 被封禁 */
+    LiveRoomStatus[LiveRoomStatus["banned"] = -1] = "banned";
+    /** 已上锁 */
+    LiveRoomStatus[LiveRoomStatus["locked"] = -2] = "locked";
+})(LiveRoomStatus || (LiveRoomStatus = {}));
+/** 直播间状态 */
+export var LiveConnectionStatus;
+(function (LiveConnectionStatus) {
+    /** 未连接 */
+    LiveConnectionStatus[LiveConnectionStatus["off"] = 0] = "off";
+    /** 连接中 */
+    LiveConnectionStatus[LiveConnectionStatus["connecting"] = 1] = "connecting";
+    /** 连接到服务器 */
+    LiveConnectionStatus[LiveConnectionStatus["connected"] = 2] = "connected";
+    /** 连接到房间 */
+    LiveConnectionStatus[LiveConnectionStatus["entered"] = 3] = "entered";
+    /** 连接失败或断开 */
+    LiveConnectionStatus[LiveConnectionStatus["disconnected"] = -1] = "disconnected";
+})(LiveConnectionStatus || (LiveConnectionStatus = {}));

package/dist/plugin/context/CommonPluginContext.d.ts

@@ -0,0 +1,45 @@
+import { App } from "../../app";
+import type { CommandOptions, CommandCallOptions, CommandFunction, AppCommandMap } from "../../command";
+import { AppError, ErrorOptions } from "../../error";
+import { AppEventListener, AppEventEmitOptions, AppEventDetailMap } from "../../event";
+import { HookUseOptions, HookCallOptions, AppHookMap, HookFunction, HookContext } from "../../hook";
+import { AppValueMap, ValueOptions } from "../../value";
+import type { PluginContext, PluginConstructor, PluginRegisterOptions } from "../types";
+export declare class CommonPluginContext implements PluginContext {
+    #private;
+    get safe(): boolean;
+    getRegisteredPlugins(): string[];
+    /** 插件名称 */
+    readonly pluginName: string;
+    constructor(app: App, pluginName: string);
+    /** 抛出错误
+     *
+     * 一般用于自身导致的错误，若非插件本身导致的错误，使用throw语句即可
+     */
+    throw(err: AppError): void;
+    error(id: string, options: ErrorOptions): AppError;
+    register(plugin: PluginConstructor, options?: PluginRegisterOptions): void;
+    unregister(pluginName: string): void;
+    getPluginExposes<T>(pluginName: string): T;
+    whenRegister<T>(pluginName: string, callback: (exposes: any) => (() => void) | undefined): (() => void) | void;
+    hasPlugin(pluginName: string): boolean;
+    registerValue<K extends keyof AppValueMap>(name: K, options: ValueOptions<AppValueMap[K]>): void;
+    unregisterValue(name: string): void;
+    registerCommand<T extends keyof AppCommandMap>(name: T, func: CommandFunction<AppCommandMap[T]>, options?: CommandOptions): void;
+    unregisterCommand(name: string): void;
+    on<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
+    once<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
+    off<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
+    emit<K extends keyof AppEventDetailMap>(type: K, detail: AppEventDetailMap[K], options?: AppEventEmitOptions & EventInit): void;
+    call<T extends keyof AppCommandMap>(name: T, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;
+    callWithOptions<T extends keyof AppCommandMap>(name: T, options: CommandCallOptions, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;
+    useHook<T extends keyof AppHookMap>(name: T, func: HookFunction<AppHookMap[T]>, options?: HookUseOptions): void;
+    unuseHook<T extends keyof AppHookMap>(name: T, func: HookFunction<AppHookMap[T]>): void;
+    callHook<T extends keyof AppHookMap>(name: T, ctx: AppHookMap[T], options?: HookCallOptions): Promise<HookContext<AppHookMap[T]>>;
+    callHookSync<T extends keyof AppHookMap>(name: T, ctx: AppHookMap[T], options?: HookCallOptions): HookContext<AppHookMap[T]>;
+    watch<K extends keyof AppValueMap>(name: K, watcher: (value: AppValueMap[K]) => void): void;
+    unwatch<K extends keyof AppValueMap>(name: K, watcher: (value: AppValueMap[K]) => void): void;
+    getValue<K extends keyof AppValueMap>(name: K): undefined;
+    setValue<K extends keyof AppValueMap>(name: K, value: AppValueMap[K]): void;
+    destroy(): void;
+}

package/dist/plugin/context/CommonPluginContext.js

@@ -0,0 +1,273 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _CommonPluginContext_app, _CommonPluginContext_registered;
+import { AppError } from "../../error";
+class ListMap extends Map {
+    addItem(key, value) {
+        const list = this.get(key);
+        if (list) {
+            list.add(value);
+        }
+        else {
+            this.set(key, new Set([value]));
+        }
+    }
+    deleteItem(key, value) {
+        this.get(key)?.delete(value);
+    }
+}
+export class CommonPluginContext {
+    get safe() {
+        return false;
+    }
+    getRegisteredPlugins() {
+        return [...__classPrivateFieldGet(this, _CommonPluginContext_registered, "f").plugins];
+    }
+    constructor(app, pluginName) {
+        /** 主程序，插件不可访问 */
+        _CommonPluginContext_app.set(this, void 0);
+        _CommonPluginContext_registered.set(this, {
+            plugins: new Set(),
+            values: new Set(),
+            commands: new Set(),
+            hooks: new ListMap(),
+            events: new ListMap(),
+        });
+        __classPrivateFieldSet(this, _CommonPluginContext_app, app, "f");
+        this.pluginName = pluginName;
+    }
+    /** 抛出错误
+     *
+     * 一般用于自身导致的错误，若非插件本身导致的错误，使用throw语句即可
+     */
+    throw(err) {
+        err.source ?? (err.source = `plugin:${this.pluginName}`);
+        throw err;
+    }
+    error(id, options) {
+        return new AppError(id, options);
+    }
+    register(plugin, options) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").register(plugin, options);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").plugins.add(plugin.name);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    unregister(pluginName) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unregister(pluginName);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").plugins.delete(pluginName);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    getPluginExposes(pluginName) {
+        return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").getPluginExposes(pluginName);
+    }
+    whenRegister(pluginName, callback) {
+        let registered = this.hasPlugin(pluginName);
+        let whenUnregistered;
+        if (registered) {
+            whenUnregistered = callback(this.getPluginExposes(pluginName));
+        }
+        this.on("plugin:register", ({ pluginName: name }) => {
+            if (pluginName == name) {
+                if (registered) {
+                    whenUnregistered?.();
+                }
+                whenUnregistered = callback(this.getPluginExposes(pluginName));
+                registered = true;
+            }
+        });
+        this.on("plugin:unregister", ({ pluginName: name }) => {
+            if (pluginName == name) {
+                whenUnregistered?.();
+                whenUnregistered = undefined;
+                registered = false;
+            }
+        });
+    }
+    hasPlugin(pluginName) {
+        return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").hasPlugin(pluginName);
+    }
+    registerValue(name, options) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").registerValue(name, options);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").values.add(name);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    unregisterValue(name) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unregisterValue(name);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").values.delete(name);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    registerCommand(name, func, options) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").registerCommand(name, func, options);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").commands.add(name);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    unregisterCommand(name) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unregisterCommand(name);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").commands.delete(name);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    on(type, listener) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").on(type, listener);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").events.addItem(type, listener);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    once(type, listener) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").once(type, listener);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").events.addItem(type, listener);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    off(type, listener) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").off(type, listener);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").events.deleteItem(type, listener);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    emit(type, detail, options) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").emit(type, detail || {}, {
+                source: `plugin:${this.pluginName}`,
+                ...options,
+            });
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    call(name, ...args) {
+        try {
+            return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").callWithOptions(name, { source: `plugin:${this.pluginName}` }, ...args);
+        }
+        catch (err) {
+            this.throw(err);
+            throw "";
+        }
+    }
+    callWithOptions(name, options, ...args) {
+        try {
+            return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").callWithOptions(name, options, ...args);
+        }
+        catch (err) {
+            this.throw(err);
+            throw "";
+        }
+    }
+    useHook(name, func, options) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").useHook(name, func, options);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").hooks.addItem(name, func);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    unuseHook(name, func) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unuseHook(name, func);
+            __classPrivateFieldGet(this, _CommonPluginContext_registered, "f").hooks.deleteItem(name, func);
+        }
+        catch (err) {
+            throw this.throw(err);
+        }
+    }
+    callHook(name, ctx, options) {
+        try {
+            return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").callHook(name, ctx);
+        }
+        catch (err) {
+            throw this.throw(err);
+        }
+    }
+    callHookSync(name, ctx, options) {
+        try {
+            return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").callHookSync(name, ctx);
+        }
+        catch (err) {
+            throw this.throw(err);
+        }
+    }
+    watch(name, watcher) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").watch(name, watcher);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    unwatch(name, watcher) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unwatch(name, watcher);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    getValue(name) {
+        try {
+            return __classPrivateFieldGet(this, _CommonPluginContext_app, "f").getValue(name);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    setValue(name, value) {
+        try {
+            __classPrivateFieldGet(this, _CommonPluginContext_app, "f").setValue(name, value);
+        }
+        catch (err) {
+            this.throw(err);
+        }
+    }
+    destroy() {
+        const { plugins, events, values, hooks, commands } = __classPrivateFieldGet(this, _CommonPluginContext_registered, "f");
+        plugins.forEach((pluginName) => __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unregister(pluginName));
+        events.forEach((listenerList, eventName) => listenerList.forEach((listener) => __classPrivateFieldGet(this, _CommonPluginContext_app, "f").off(eventName, listener)));
+        hooks.forEach((hookList, name) => hookList.forEach((hookFunc) => __classPrivateFieldGet(this, _CommonPluginContext_app, "f").off(name, hookFunc)));
+        commands.forEach((name) => __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unregisterCommand(name));
+        values.forEach((name) => __classPrivateFieldGet(this, _CommonPluginContext_app, "f").unregisterValue(name));
+    }
+}
+_CommonPluginContext_app = new WeakMap(), _CommonPluginContext_registered = new WeakMap();

package/dist/plugin/context/SafePluginContext.d.ts

@@ -0,0 +1,34 @@
+import { App } from "../../app";
+import { AppCommandMap, CommandCallOptions, CommandFunction, CommandOptions } from "../../command";
+import { AppEventDetailMap, AppEventEmitOptions } from "../../event";
+import { AppHookMap, HookCallOptions, HookContext, HookFunction, HookUseOptions } from "../../hook";
+import { PluginConstructor, PluginRegisterOptions } from "../types";
+import { CommonPluginContext } from "./CommonPluginContext";
+export interface PluginPermissions {
+    "plugin.register"?: boolean;
+    "event.emit"?: string[];
+    "event.emit.advanced"?: boolean;
+    "command.register"?: string[];
+    "command.call"?: string[];
+    "command.call.advanced"?: boolean;
+    "value.register"?: string[];
+    "hook.use"?: string[];
+    "hook.call"?: string[];
+}
+export declare class SafePluginContext extends CommonPluginContext {
+    #private;
+    get safe(): boolean;
+    constructor(app: App, pluginName: string, options: {
+        permissions: PluginPermissions;
+    });
+    private throwNotPermitted;
+    register(plugin: PluginConstructor, options?: PluginRegisterOptions): void;
+    unregister(pluginName: string): void;
+    emit<K extends keyof AppEventDetailMap>(type: K, detail: AppEventDetailMap[K], options?: AppEventEmitOptions & EventInit): void;
+    call<T extends keyof AppCommandMap>(name: T, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;
+    callWithOptions<T extends keyof AppCommandMap>(name: T, options: CommandCallOptions, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;
+    registerCommand<T extends keyof AppCommandMap>(name: T, func: CommandFunction<AppCommandMap[T]>, options?: CommandOptions): void;
+    useHook<T extends keyof AppHookMap>(name: T, func: HookFunction<AppHookMap[T]>, options?: HookUseOptions): void;
+    unuseHook<T extends keyof AppHookMap>(name: T, func: HookFunction<AppHookMap[T]>): void;
+    callHook<T extends keyof AppHookMap>(name: T, ctx: AppHookMap[T], options?: HookCallOptions): Promise<HookContext<AppHookMap[T]>>;
+}