node-plume 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,918 @@
+import * as _plume_types from '@plume/types';
+import { SendTarget, MessageContent, Awaitable, SendMessageResult, EventPayload, Timestamp, MessagePayload, MessageId, UserInfo, UserId, GroupId, NoticePayload, NoticeSubtype, GroupInfo, RequestPayload, RequestSubtype, APIResponse, APIHandler, APIRequest, APIError, AdapterEvent, MessageSegment, TextSegment, ImageSegment, AudioSegment, VideoSegment, FileSegment, AtSegment, FaceSegment, ReplySegment, ForwardSegment, ForwardNode, LocationSegment, JsonSegment, XmlSegment, CustomSegment } from '@plume/types';
+export { ErrorCode, EventPayload, MessagePayload, NoticePayload, RequestPayload } from '@plume/types';
+import { LogLevel, Logger } from '@plume/logger';
+import { ChildProcess } from 'node:child_process';
+
+declare class ServiceContainer {
+    private readonly services;
+    private readonly factories;
+    register<T>(name: string, service: T): this;
+    registerFactory<T>(name: string, factory: () => T): this;
+    resolve<T>(name: string): T;
+    has(name: string): boolean;
+    delete(name: string): boolean;
+    clear(): void;
+    get<T>(name: string): T | undefined;
+    set<T>(name: string, service: T): this;
+    keys(): string[];
+    entries(): Array<[string, unknown]>;
+    size(): number;
+}
+
+interface SendMessageParams {
+    target: SendTarget;
+    content: MessageContent;
+    replyTo?: string;
+}
+interface MessageSender {
+    sendMessage(params: SendMessageParams): Awaitable<SendMessageResult>;
+}
+declare class MessageService {
+    private sender;
+    registerSender(sender: MessageSender): this;
+    clearSender(): this;
+    hasSender(): boolean;
+    sendMessage(params: SendMessageParams): Promise<SendMessageResult>;
+}
+
+interface InitConfigOptions {
+    path?: string;
+}
+interface InitConfigResult {
+    configDirectory: string;
+    createdConfigFiles: string[];
+}
+declare function initConfig(options?: InitConfigOptions): InitConfigResult;
+
+interface PlumeDefaultConfig {
+    app: {
+        name: string;
+        version: string;
+    };
+    log: {
+        level: string;
+        timestamp: boolean;
+    };
+    transport: {
+        host: string;
+        port: number;
+        path: string;
+        wsPath: string;
+        cors: boolean;
+        enableHttp: boolean;
+        enableWebSocket: boolean;
+        maxBodySize: number;
+    };
+}
+declare const plumeDefaultConfig: Readonly<PlumeDefaultConfig>;
+
+interface ConfigOptions {
+    path?: string;
+    watch?: boolean;
+    initialize?: boolean;
+}
+type ConfigSource = 'file' | 'env' | 'default';
+interface ConfigEntry<T = unknown> {
+    value: T;
+    source: ConfigSource;
+}
+declare class ConfigService {
+    private config;
+    private path;
+    constructor(options?: ConfigOptions);
+    initialize(options?: InitConfigOptions): InitConfigResult;
+    loadDefaults(): this;
+    loadFile(path?: string): this;
+    loadDirectory(path?: string): this;
+    loadObject(data: Record<string, unknown>, source?: ConfigSource): this;
+    reload(): this;
+    get<T = unknown>(key: string, defaultValue?: T): T;
+    set<T>(key: string, value: T, source?: ConfigSource): this;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    getSource(key: string): ConfigSource | undefined;
+    getAll(): Record<string, unknown>;
+    entries(): Array<[string, ConfigEntry]>;
+    clear(): void;
+}
+
+interface DatabaseOptions {
+    type: 'sqlite' | 'memory';
+    path?: string;
+    timeout?: number;
+}
+interface QueryResult {
+    changes: number;
+    lastInsertRowid?: number | string;
+}
+interface DatabaseAdapter {
+    connect(): Awaitable<void>;
+    disconnect(): Awaitable<void>;
+    query<T = unknown>(sql: string, params?: unknown[]): Awaitable<T[]>;
+    execute(sql: string, params?: unknown[]): Awaitable<QueryResult>;
+    transaction<T>(fn: () => Awaitable<T>): Awaitable<T>;
+    isConnected(): boolean;
+}
+declare class DatabaseService {
+    private adapter;
+    private options;
+    constructor(options: DatabaseOptions);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private createAdapter;
+    query<T = unknown>(sql: string, params?: unknown[]): Promise<T[]>;
+    execute(sql: string, params?: unknown[]): Promise<QueryResult>;
+    transaction<T>(fn: () => Awaitable<T>): Promise<T>;
+    isConnected(): boolean;
+    private ensureConnected;
+    get<T = unknown>(table: string, id: string | number): Promise<T | undefined>;
+    find<T = unknown>(table: string, conditions: Record<string, unknown>): Promise<T[]>;
+    insert(table: string, data: Record<string, unknown>): Promise<QueryResult>;
+    update(table: string, id: string | number, data: Record<string, unknown>): Promise<QueryResult>;
+    delete(table: string, id: string | number): Promise<QueryResult>;
+}
+
+interface LogServiceOptions {
+    level?: LogLevel;
+    prefix?: string;
+    timestamp?: boolean;
+    outputs?: LogOutput[];
+}
+interface LogOutput {
+    type: 'console' | 'file' | 'custom';
+    handler?: (level: LogLevel, message: string, ...args: unknown[]) => void;
+    path?: string;
+}
+interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: Date;
+    args: unknown[];
+    prefix?: string;
+}
+declare class LogService {
+    private logger;
+    private options;
+    private outputs;
+    private buffer;
+    private maxBufferSize;
+    private suspended;
+    private pending;
+    constructor(options?: LogServiceOptions);
+    get level(): LogLevel;
+    setLevel(level: LogLevel): void;
+    suspend(): this;
+    resume(): this;
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+    private log;
+    private writeEntry;
+    private writeToOutput;
+    addOutput(output: LogOutput): this;
+    removeOutput(output: LogOutput): boolean;
+    child(prefix: string): LogService;
+    getBuffer(): LogEntry[];
+    clearBuffer(): void;
+    flush(): void;
+}
+declare const logService: LogService;
+
+declare abstract class BaseEvent<T extends EventPayload = EventPayload> {
+    protected readonly payload: T;
+    abstract readonly type: T['type'];
+    readonly timestamp: Timestamp;
+    readonly raw: T['raw'];
+    constructor(payload: T);
+    get selfId(): string;
+}
+
+declare class MessageEvent extends BaseEvent<MessagePayload> {
+    readonly type: "message";
+    get messageId(): MessageId;
+    get content(): MessageContent;
+    get text(): string;
+    get sender(): UserInfo;
+    get target(): {
+        type: 'private' | 'group';
+        id: UserId | GroupId;
+    };
+    get isPrivate(): boolean;
+    get isGroup(): boolean;
+    get userId(): UserId;
+    get groupId(): GroupId | undefined;
+}
+
+declare class NoticeEvent extends BaseEvent<NoticePayload> {
+    readonly type: "notice";
+    get subtype(): NoticeSubtype;
+    get operator(): UserInfo | undefined;
+    get targetUser(): UserInfo | undefined;
+    get group(): GroupInfo | undefined;
+    get data(): Record<string, unknown> | undefined;
+    isGroupIncrease(): this is this & {
+        subtype: 'group_increase';
+    };
+    isGroupDecrease(): this is this & {
+        subtype: 'group_decrease';
+    };
+    isGroupAdmin(): this is this & {
+        subtype: 'group_admin';
+    };
+    isGroupUpload(): this is this & {
+        subtype: 'group_upload';
+    };
+    isFriendAdd(): this is this & {
+        subtype: 'friend_add';
+    };
+    isFriendRecall(): this is this & {
+        subtype: 'friend_recall';
+    };
+    isGroupRecall(): this is this & {
+        subtype: 'group_recall';
+    };
+}
+
+declare class RequestEvent extends BaseEvent<RequestPayload> {
+    readonly type: "request";
+    get subtype(): RequestSubtype;
+    get requestId(): string;
+    get sender(): UserInfo;
+    get group(): GroupInfo | undefined;
+    get comment(): string | undefined;
+    isFriendRequest(): this is this & {
+        subtype: 'friend';
+    };
+    isGroupInvite(): this is this & {
+        subtype: 'group_invite';
+    };
+}
+
+declare class Context {
+    readonly app: App;
+    readonly event: MessageEvent;
+    readonly state: Map<string, unknown>;
+    constructor(app: App, event: MessageEvent);
+    get messageId(): string;
+    get text(): string;
+    get content(): MessageContent;
+    get sender(): _plume_types.UserInfo;
+    get userId(): UserId;
+    get groupId(): GroupId | undefined;
+    get isPrivate(): boolean;
+    get isGroup(): boolean;
+    get target(): SendTarget;
+    get selfId(): string;
+    get timestamp(): number;
+    get raw(): unknown;
+    get services(): ServiceContainer;
+    setState<T>(key: string, value: T): this;
+    getState<T>(key: string): T | undefined;
+    reply(content: ReplyInput, options?: Omit<SendMessageOptions, 'replyTo'>): Promise<APIResponse<SendMessageResult>>;
+}
+
+type RouteHandler = APIHandler<unknown, unknown>;
+declare class APIRouter {
+    private routes;
+    route(action: string, handler: RouteHandler): void;
+    match(action: string): RouteHandler | undefined;
+    has(action: string): boolean;
+    remove(action: string): boolean;
+    clear(): void;
+    getActions(): string[];
+}
+
+interface APIClientOptions {
+    timeout?: number;
+    baseUrl?: string;
+    token?: string;
+}
+declare class APIClient {
+    private router;
+    private options;
+    constructor(options?: APIClientOptions);
+    call<T = unknown>(request: APIRequest): Promise<APIResponse<T>>;
+    on<T = unknown, R = unknown>(action: string, handler: APIHandler<T, R>): this;
+    register(handlers: Record<string, APIHandler>): this;
+    getRouter(): APIRouter;
+    getActions(): string[];
+    getActionCount(): number;
+    private createErrorResponse;
+    private createTimeoutPromise;
+}
+
+declare class APIErrorClass extends Error {
+    readonly code: number;
+    readonly details?: Record<string, unknown>;
+    constructor(code: number, message: string, details?: Record<string, unknown>);
+    toAPIError(): APIError;
+    static fromCode(code: number, message?: string, details?: Record<string, unknown>): APIErrorClass;
+}
+declare function createSuccessResponse<T>(data: T, startTime: number): APIResponse<T>;
+declare function createErrorResponse(code: number, message: string, startTime: number, details?: Record<string, unknown>): APIResponse;
+declare function isAPIError(error: unknown): error is APIErrorClass;
+
+interface MiddlewareContext$1 {
+    request: APIRequest;
+    response?: APIResponse;
+    next: () => Promise<APIResponse>;
+}
+type Middleware$1 = (ctx: MiddlewareContext$1) => Awaitable<APIResponse | void>;
+declare class MiddlewareChain {
+    private middlewares;
+    use(middleware: Middleware$1): this;
+    execute(request: APIRequest, handler: () => Promise<APIResponse>): Promise<APIResponse>;
+    clear(): void;
+}
+
+interface TokenPayload {
+    iss?: string;
+    sub?: string;
+    aud?: string;
+    exp?: number;
+    iat?: number;
+    jti?: string;
+    [key: string]: unknown;
+}
+interface AuthConfig {
+    secret: string;
+    expiresIn?: number;
+    issuer?: string;
+    audience?: string;
+}
+interface AuthProvider {
+    verify(token: string): Awaitable<TokenPayload | null>;
+    sign(payload: TokenPayload): Awaitable<string>;
+}
+declare class TokenAuth implements AuthProvider {
+    private config;
+    constructor(config: AuthConfig);
+    verify(token: string): Promise<TokenPayload | null>;
+    sign(payload: TokenPayload): Promise<string>;
+    private createSignature;
+}
+declare function extractToken(request: APIRequest): string | null;
+declare function createAuthMiddleware(authProvider: AuthProvider): (ctx: {
+    request: APIRequest;
+    next: () => Promise<APIResponse>;
+}) => Promise<APIResponse | void>;
+
+interface APITransportOptions {
+    host?: string;
+    port?: number;
+    path?: string;
+    wsPath?: string;
+    cors?: boolean;
+    enableHttp?: boolean;
+    enableWebSocket?: boolean;
+    maxBodySize?: number;
+    authProvider?: AuthProvider;
+    middlewares?: Middleware$1[];
+}
+interface APITransportAddress {
+    host: string;
+    port: number;
+    httpUrl?: string;
+    wsUrl?: string;
+}
+declare class APITransportServer {
+    private readonly apiClient;
+    private readonly logger?;
+    private readonly middlewareChain;
+    private readonly clients;
+    private readonly connections;
+    private readonly options;
+    private server;
+    private address;
+    constructor(apiClient: APIClient, options?: APITransportOptions, logger?: LogService);
+    start(): Promise<APITransportAddress>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    isEnabled(): boolean;
+    getAddress(): APITransportAddress | null;
+    getConnectedClientCount(): number;
+    private handleHTTPRequest;
+    private handleUpgrade;
+    private handleWebSocketData;
+    private handleWebSocketMessage;
+    private executeRequest;
+    private normalizeRequest;
+    private readRequestBody;
+    private applyCORSHeaders;
+    private extractBearerToken;
+    private writeJSON;
+    private createWebSocketAccept;
+    private sendWebSocketJSON;
+    private sendWebSocketFrame;
+    private tryParseFrame;
+}
+
+interface DispatchEventParams {
+    event: AdapterEvent | EventPayload;
+}
+interface DispatchEventResult {
+    type: EventPayload['type'];
+    timestamp: number;
+    selfId: string;
+}
+type EventLogDirection = 'in' | 'out';
+interface EventLogOptions {
+    direction?: EventLogDirection;
+    adapter?: string;
+    botId?: string;
+}
+interface MessageLogInput {
+    target: SendTarget;
+    content: MessageContent;
+    replyTo?: string;
+}
+interface BotOptions {
+    id: string;
+    adapter: string;
+    logger?: LogService;
+    loggerPrefix?: string;
+}
+declare class Bot {
+    readonly app: App;
+    readonly logger: LogService;
+    readonly id: string;
+    readonly adapter: string;
+    constructor(app: App, options: BotOptions);
+    dispatchEvent(event: AdapterEvent | EventPayload): Promise<APIResponse<DispatchEventResult>>;
+    sendMessage(target: SendTarget, content: MessageContent, options?: SendMessageOptions): Promise<APIResponse<SendMessageResult>>;
+}
+declare function normalizeEventPayload(event: AdapterEvent | EventPayload): EventPayload;
+declare function buildEventLog(event: AdapterEvent | EventPayload, _options?: EventLogOptions): string;
+declare function buildSendMessageLog(input: MessageLogInput, _options?: EventLogOptions): string;
+
+interface FrameworkInfo {
+    name: string;
+    running: boolean;
+    uptime: number;
+    startedAt: number;
+    pluginCount: number;
+    serviceCount: number;
+    actionCount: number;
+}
+interface FrameworkPluginInfo {
+    name: string;
+    version?: string;
+    priority: number;
+}
+interface FrameworkServiceInfo {
+    name: string;
+    kind: string;
+}
+interface StandardActionMap {
+    get_framework_info: APIHandler;
+    get_plugin_list: APIHandler;
+    get_service_list: APIHandler;
+    get_action_list: APIHandler;
+    get_runtime_snapshot: APIHandler;
+    dispatch_event: APIHandler<DispatchEventParams, DispatchEventResult>;
+    send_message: APIHandler<SendMessageParams, SendMessageResult>;
+}
+declare const STANDARD_ACTION_NAMES: readonly ["get_framework_info", "get_plugin_list", "get_service_list", "get_action_list", "get_runtime_snapshot", "dispatch_event", "send_message"];
+declare function createStandardActions(app: App, apiClient: APIClient, startedAt: number): StandardActionMap;
+declare function registerStandardActions(app: App, apiClient: APIClient, startedAt: number): string[];
+
+type EventHandler<T = unknown> = (data: T) => Awaitable<void>;
+interface EventMapBase {
+    [key: string]: unknown;
+}
+declare class EventEmitter<EventMap extends EventMapBase> {
+    private readonly handlers;
+    on<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): this;
+    once<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): this;
+    off<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): this;
+    emit<K extends keyof EventMap>(event: K, data: EventMap[K]): Promise<void>;
+    listenerCount<K extends keyof EventMap>(event: K): number;
+    removeAllListeners<K extends keyof EventMap>(event?: K): this;
+}
+
+type LifecycleHookName = 'beforeStart' | 'afterStart' | 'beforeStop' | 'afterStop' | 'beforePluginSetup' | 'afterPluginSetup' | 'beforePluginDispose' | 'afterPluginDispose';
+type LifecycleHookHandler = (app: App) => Awaitable<void>;
+declare class LifecycleHookManager {
+    private hooks;
+    on(name: LifecycleHookName, handler: LifecycleHookHandler): this;
+    off(name: LifecycleHookName, handler: LifecycleHookHandler): boolean;
+    emit(name: LifecycleHookName, app: App): Promise<void>;
+    has(name: LifecycleHookName): boolean;
+    count(name: LifecycleHookName): number;
+    clear(name?: LifecycleHookName): void;
+}
+
+type EventHookName = 'beforeMessage' | 'afterMessage' | 'beforeNotice' | 'afterNotice' | 'beforeRequest' | 'afterRequest' | 'messageReceived' | 'noticeReceived' | 'requestReceived';
+type EventHookHandler<T = unknown> = (data: T) => Awaitable<boolean | void>;
+interface MessageHookContext {
+    ctx: Context;
+    event: MessageEvent;
+}
+interface NoticeHookContext {
+    event: NoticeEvent;
+}
+interface RequestHookContext {
+    event: RequestEvent;
+}
+declare class EventHooks {
+    private messageHooks;
+    private noticeHooks;
+    private requestHooks;
+    onMessage(name: 'beforeMessage' | 'afterMessage' | 'messageReceived', handler: EventHookHandler<MessageHookContext>): this;
+    onNotice(name: 'beforeNotice' | 'afterNotice' | 'noticeReceived', handler: EventHookHandler<NoticeHookContext>): this;
+    onRequest(name: 'beforeRequest' | 'afterRequest' | 'requestReceived', handler: EventHookHandler<RequestHookContext>): this;
+    offMessage(name: 'beforeMessage' | 'afterMessage' | 'messageReceived', handler: EventHookHandler<MessageHookContext>): boolean;
+    offNotice(name: 'beforeNotice' | 'afterNotice' | 'noticeReceived', handler: EventHookHandler<NoticeHookContext>): boolean;
+    offRequest(name: 'beforeRequest' | 'afterRequest' | 'requestReceived', handler: EventHookHandler<RequestHookContext>): boolean;
+    emitMessage(name: 'beforeMessage' | 'afterMessage' | 'messageReceived', data: MessageHookContext): Promise<boolean>;
+    emitNotice(name: 'beforeNotice' | 'afterNotice' | 'noticeReceived', data: NoticeHookContext): Promise<boolean>;
+    emitRequest(name: 'beforeRequest' | 'afterRequest' | 'requestReceived', data: RequestHookContext): Promise<boolean>;
+    clear(): void;
+}
+
+type ErrorHookName = 'onError' | 'onPluginError' | 'onMiddlewareError' | 'onHookError' | 'onUnhandledRejection' | 'onUncaughtException';
+type ErrorHookHandler = (error: Error, context?: Record<string, unknown>) => Awaitable<boolean | void>;
+declare class ErrorHooks {
+    private hooks;
+    private app;
+    private readonly handleUnhandledRejection;
+    private readonly handleUncaughtException;
+    private globalHandlersAttached;
+    constructor(app: App);
+    on(name: ErrorHookName, handler: ErrorHookHandler): this;
+    off(name: ErrorHookName, handler: ErrorHookHandler): boolean;
+    emit(name: ErrorHookName, error: Error, context?: Record<string, unknown>): Promise<boolean>;
+    private setupGlobalHandlers;
+    has(name: ErrorHookName): boolean;
+    count(name: ErrorHookName): number;
+    clear(name?: ErrorHookName): void;
+    destroy(): void;
+}
+
+interface Plugin {
+    readonly name: string;
+    readonly version?: string;
+    readonly priority?: number;
+    setup(app: App): Awaitable<void>;
+    dispose?(app: App): Awaitable<void>;
+    onMessage?(ctx: Context): Awaitable<boolean | void>;
+    onNotice?(event: NoticeEvent): Awaitable<void>;
+    onRequest?(event: RequestEvent): Awaitable<void>;
+}
+interface PluginHooks {
+    lifecycle?: Partial<Record<LifecycleHookName, (app: App) => Awaitable<void>>>;
+    events?: {
+        beforeMessage?: (ctx: Context, event: MessageEvent) => Awaitable<boolean | void>;
+        afterMessage?: (ctx: Context, event: MessageEvent) => Awaitable<void>;
+        beforeNotice?: (event: NoticeEvent) => Awaitable<boolean | void>;
+        afterNotice?: (event: NoticeEvent) => Awaitable<void>;
+        beforeRequest?: (event: RequestEvent) => Awaitable<boolean | void>;
+        afterRequest?: (event: RequestEvent) => Awaitable<void>;
+    };
+    errors?: Partial<Record<ErrorHookName, (error: Error) => Awaitable<boolean | void>>>;
+}
+type PluginSetup = (app: App) => Awaitable<void>;
+type PluginDispose = (app: App) => Awaitable<void>;
+interface DefinePluginOptions {
+    name: string;
+    version?: string;
+    priority?: number;
+    setup: PluginSetup;
+    dispose?: PluginDispose;
+}
+declare abstract class BasePlugin implements Plugin {
+    abstract readonly name: string;
+    readonly version?: string;
+    readonly priority: number;
+    readonly hooks?: PluginHooks;
+    abstract setup(app: App): Awaitable<void>;
+    dispose?(app: App): Awaitable<void>;
+    onMessage?(ctx: Context): Awaitable<boolean | void>;
+    onNotice?(event: NoticeEvent): Awaitable<void>;
+    onRequest?(event: RequestEvent): Awaitable<void>;
+}
+declare function definePlugin(options: DefinePluginOptions): Plugin;
+
+interface PluginManagerOptions {
+    autoDispose?: boolean;
+}
+declare class PluginManager {
+    private plugins;
+    private app;
+    private options;
+    constructor(app: App, options?: PluginManagerOptions);
+    getAutoDispose(): boolean;
+    register(plugin: Plugin): this;
+    unregister(name: string): this;
+    get(name: string): Plugin | undefined;
+    has(name: string): boolean;
+    setupAll(): Promise<void>;
+    disposeAll(): Promise<void>;
+    private getSortedPlugins;
+    list(): Plugin[];
+    clear(): void;
+}
+
+type MiddlewareNext = () => Awaitable<void>;
+interface MiddlewareContext {
+    type: 'message' | 'notice' | 'request';
+    payload: MessagePayload | NoticePayload | RequestPayload;
+    event?: MessageEvent | NoticeEvent | RequestEvent;
+    ctx?: Context;
+}
+type Middleware = (ctx: MiddlewareContext, next: MiddlewareNext) => Awaitable<void>;
+declare class MiddlewareManager {
+    private middlewares;
+    use(middleware: Middleware): this;
+    remove(middleware: Middleware): boolean;
+    execute(ctx: MiddlewareContext): Promise<void>;
+    clear(): void;
+    get count(): number;
+}
+declare function compose(middlewares: Middleware[]): Middleware;
+
+declare function text(value: string): TextSegment;
+declare function image(source: string | ImageSegment['data']): ImageSegment;
+declare function audio(source: string | AudioSegment['data']): AudioSegment;
+declare function video(source: string | VideoSegment['data']): VideoSegment;
+declare function file(source: string | FileSegment['data'], name?: string): FileSegment;
+declare function at(userId: string, name?: string): AtSegment;
+declare function face(id: number, name?: string): FaceSegment;
+declare function reply(messageId: string): ReplySegment;
+declare function forward(id: string): ForwardSegment;
+declare function forward(messages: ForwardNode[]): ForwardSegment;
+declare function forward(data: ForwardSegment['data']): ForwardSegment;
+declare function location(latitude: number, longitude: number, title?: string, content?: string): LocationSegment;
+declare function location(data: LocationSegment['data']): LocationSegment;
+declare function json(data: string | Record<string, unknown>): JsonSegment;
+declare function xml(data: string): XmlSegment;
+declare function custom(data: Record<string, unknown>): CustomSegment;
+declare function custom(type: string, data: Record<string, unknown>): MessageSegment;
+declare const segment: {
+    text: typeof text;
+    image: typeof image;
+    audio: typeof audio;
+    video: typeof video;
+    file: typeof file;
+    at: typeof at;
+    face: typeof face;
+    reply: typeof reply;
+    forward: typeof forward;
+    location: typeof location;
+    json: typeof json;
+    xml: typeof xml;
+    custom: typeof custom;
+};
+declare function normalizeMessageContent(content: MessageContent): MessageContent;
+declare function normalizeMessageSegment(segment: MessageSegment): MessageSegment;
+declare function extractMessageText(content: MessageContent): string;
+declare function formatMessageContent(content: MessageContent): string;
+declare function renderMessageSegment(segment: MessageSegment): string;
+declare function formatMessageSegment(segment: MessageSegment): string;
+
+interface AppConfig {
+    name?: string;
+    logger?: {
+        level?: LogLevel;
+        prefix?: string;
+    };
+}
+interface SendMessageOptions {
+    replyTo?: string;
+    at?: boolean;
+    reply?: boolean;
+    recallMsg?: number;
+    retryCount?: number;
+}
+type ReplyInput = MessageContent | MessageSegment | Array<string | MessageSegment>;
+interface FunctionalCommandOptions {
+    name?: string;
+    log?: boolean;
+    event?: 'message';
+    perm?: string;
+    at?: boolean;
+    reply?: boolean;
+    recallMsg?: number;
+    retryCount?: number;
+    rank?: number;
+    adapter?: string[];
+    dsbAdapter?: string[];
+    delay?: number;
+    stop?: boolean;
+    authFailMsg?: string;
+}
+interface CommandOptions {
+    aliases?: string[];
+    prefix?: string | string[];
+    caseSensitive?: boolean;
+}
+interface CommandContext {
+    app: App;
+    command: string;
+    args: string[];
+    rawArgs: string;
+    event: MessageEvent;
+    text: string;
+    sender: MessageEvent['sender'];
+    userId: MessageEvent['userId'];
+    groupId: MessageEvent['groupId'];
+    isPrivate: boolean;
+    isGroup: boolean;
+    reply: (content: MessageContent) => Promise<APIResponse<SendMessageResult>>;
+}
+type CommandHandler = (command: CommandContext) => Awaitable<unknown>;
+interface CommandDefinition extends CommandOptions {
+    handler: CommandHandler;
+}
+type AppCommandMap = Record<string, CommandHandler | CommandDefinition>;
+type AppModuleSetup = (app: App, logger: LogService) => Awaitable<void>;
+type FunctionalCommandNext = () => void;
+type FunctionalCommandContext = Context & {
+    logger: LogService;
+    match: RegExpMatchArray;
+};
+type PlumeEvent = FunctionalCommandContext;
+type PlumeNext = FunctionalCommandNext;
+type FunctionalCommandHandler = (e: FunctionalCommandContext, next: FunctionalCommandNext) => Awaitable<unknown>;
+type FunctionalCommandReply = FunctionalCommandHandler | ReplyInput;
+interface DefineAppOptions {
+    log?: boolean;
+    commands?: AppCommandMap;
+}
+interface AppModuleDefinition {
+    __plumeAppModule?: true;
+    name?: string;
+    log?: boolean;
+    setup?: AppModuleSetup;
+    commands?: AppCommandMap;
+}
+declare function defineApp(definition: Omit<AppModuleDefinition, '__plumeAppModule'>): AppModuleDefinition;
+declare function defineApp(name: string, setup: AppModuleSetup, options?: DefineAppOptions): AppModuleDefinition;
+declare function command(pattern: string | RegExp, handler: FunctionalCommandReply, options?: FunctionalCommandOptions): AppModuleDefinition;
+declare const Plume: {
+    command: typeof command;
+};
+interface AppEventMap {
+    [key: string]: unknown;
+    'ready': void;
+    'message': {
+        ctx: Context;
+        event: MessageEvent;
+    };
+    'notice': {
+        event: NoticeEvent;
+    };
+    'request': {
+        event: RequestEvent;
+    };
+    'error': {
+        error: unknown;
+    };
+    'stop': void;
+}
+declare class App {
+    readonly services: ServiceContainer;
+    readonly events: EventEmitter<AppEventMap>;
+    readonly logger: Logger;
+    readonly name: string;
+    private running;
+    private readonly plugins;
+    constructor(config?: AppConfig);
+    use(plugin: Plugin): this;
+    plugin(plugin: Plugin): this;
+    registerService<T>(name: string, service: T): this;
+    on<K extends keyof AppEventMap>(event: K, handler: (data: AppEventMap[K]) => Awaitable<void>): this;
+    ready(handler: (data: AppEventMap['ready']) => Awaitable<void>): this;
+    message(handler: (data: AppEventMap['message']) => Awaitable<void>): this;
+    command(name: string, handler: CommandHandler, options?: CommandOptions): this;
+    commands(commandMap: AppCommandMap): this;
+    notice(handler: (data: AppEventMap['notice']) => Awaitable<void>): this;
+    request(handler: (data: AppEventMap['request']) => Awaitable<void>): this;
+    error(handler: (data: AppEventMap['error']) => Awaitable<void>): this;
+    stopped(handler: (data: AppEventMap['stop']) => Awaitable<void>): this;
+    once<K extends keyof AppEventMap>(event: K, handler: (data: AppEventMap[K]) => Awaitable<void>): this;
+    off<K extends keyof AppEventMap>(event: K, handler: (data: AppEventMap[K]) => Awaitable<void>): this;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    get api(): APIClient;
+    get transport(): APITransportServer | undefined;
+    setMessageSender(sender: MessageSender): this;
+    getMessageService(): MessageService | undefined;
+    action<T = unknown, R = unknown>(name: string, handler: APIHandler<T, R>): this;
+    actions(handlers: Record<string, APIHandler>): this;
+    service<T>(name: string): T;
+    getService<T>(name: string): T | undefined;
+    listPlugins(): Plugin[];
+    pluginCount(): number;
+    call<T = unknown>(request: APIRequest): Promise<APIResponse<T>>;
+    sendMessage(target: SendTarget, content: MessageContent, options?: SendMessageOptions): Promise<APIResponse<SendMessageResult>>;
+    dispatch(payload: EventPayload): Promise<void>;
+    private handleError;
+    private getPluginsInOrder;
+}
+
+interface ConsoleAdapterOptions {
+    selfId?: string;
+    adapter?: string;
+    userId?: string;
+    nickname?: string;
+    targetType?: 'private' | 'group';
+    groupId?: string;
+    loggerPrefix?: string;
+}
+declare function createConsoleAdapter(options?: ConsoleAdapterOptions): Plugin;
+
+interface LauncherOptions {
+    entry?: string;
+    cwd?: string;
+    watch?: boolean;
+    env?: Record<string, string>;
+}
+interface LauncherStats {
+    startTime: number;
+    restartCount: number;
+    lastRestartTime: number;
+}
+type LauncherState = 'idle' | 'starting' | 'running' | 'stopping' | 'stopped';
+type LauncherEvent = 'start' | 'restart' | 'stop' | 'exit' | 'error';
+interface LauncherEventHandler {
+    (event: LauncherEvent, data?: unknown): void;
+}
+declare class ProcessLauncher {
+    private process;
+    private state;
+    private stats;
+    private eventHandlers;
+    private options;
+    private shutdownPromise;
+    private resolveShutdown;
+    private static readonly DEFAULT_OPTIONS;
+    constructor(options?: LauncherOptions);
+    private setupSignalHandlers;
+    start(): Promise<ChildProcess>;
+    restart(): Promise<ChildProcess | null>;
+    stop(): Promise<void>;
+    kill(): void;
+    getState(): LauncherState;
+    getStats(): LauncherStats;
+    getUptime(): number;
+    on(event: LauncherEvent, handler: LauncherEventHandler): this;
+    off(event: LauncherEvent, handler: LauncherEventHandler): this;
+    private emit;
+    private setupProcessEventHandlers;
+    private handleProcessExit;
+    private handleProcessError;
+    private handleProcessMessage;
+    private resolveEntry;
+}
+declare function launch(options?: LauncherOptions): Promise<ProcessLauncher>;
+
+declare global {
+    var logger: LogService;
+}
+
+interface StartOptions extends AppConfig {
+    app?: App;
+    plugins?: Plugin[];
+    services?: Record<string, unknown>;
+    config?: ConfigOptions;
+    transport?: APITransportOptions | false;
+    setup?: (app: App) => Awaitable<void>;
+    onStarted?: (app: App) => Awaitable<void>;
+}
+type AppSetup = (app: App) => Awaitable<void>;
+interface FrameworkServices {
+    logger: LogService;
+    lifecycleHooks: LifecycleHookManager;
+    errorHooks: ErrorHooks;
+    apiClient: APIClient;
+    builtInActions: string[];
+    transportServer: APITransportServer;
+    config: ConfigService;
+}
+interface StandardInterfaceDescriptor {
+    requestFormat: 'APIRequest';
+    responseFormat: 'APIResponse';
+    authProvider: 'TokenAuth';
+    middleware: 'MiddlewareChain';
+    actions: string[];
+}
+interface PlumePackageManifest {
+    entry?: string;
+    appDirs?: string[];
+    sourceAppDirs?: string[];
+    assetDirs?: string[];
+    include?: string[];
+}
+declare const logger: LogService;
+declare function createApp(config?: AppConfig): App;
+declare function getCurrentApp(): App | null;
+declare function getFrameworkServices(app: App): FrameworkServices;
+declare function start(setup: AppSetup): Promise<App>;
+declare function start(options?: StartOptions): Promise<App>;
+declare function stop(app?: App | null): Promise<void>;
+
+export { APIClient, type APIClientOptions, APIErrorClass as APIError, APIRouter, type APITransportAddress, type APITransportOptions, APITransportServer, App, type AppCommandMap, type AppConfig, type AppModuleDefinition, type AppModuleSetup, type AppSetup, type AuthConfig, type AuthProvider, BaseEvent, BasePlugin, Bot, type BotOptions, type CommandContext, type CommandDefinition, type CommandHandler, type CommandOptions, type ConfigEntry, type ConfigOptions, ConfigService, type ConfigSource, type ConsoleAdapterOptions, Context, type DatabaseAdapter, type DatabaseOptions, DatabaseService, type DefineAppOptions, type DefinePluginOptions, type DispatchEventParams, type DispatchEventResult, type ErrorHookName, ErrorHooks, EventEmitter, type EventHookName, EventHooks, type EventLogDirection, type EventLogOptions, type FrameworkInfo, type FrameworkPluginInfo, type FrameworkServiceInfo, type FrameworkServices, type FunctionalCommandContext, type FunctionalCommandHandler, type FunctionalCommandNext, type FunctionalCommandOptions, type FunctionalCommandReply, type InitConfigOptions, type InitConfigResult, type LauncherEvent, type LauncherEventHandler, type LauncherOptions, type LauncherState, type LauncherStats, type LifecycleHookHandler, LifecycleHookManager, type LifecycleHookName, type LogEntry, type LogOutput, LogService, type LogServiceOptions, MessageEvent, type MessageLogInput, type MessageSender, MessageService, type Middleware, MiddlewareChain, type MiddlewareContext, MiddlewareManager, type MiddlewareNext, NoticeEvent, type Plugin, type PluginDispose, type PluginHooks, PluginManager, type PluginManagerOptions, type PluginSetup, Plume, type PlumeDefaultConfig, type PlumeEvent, type PlumeNext, type PlumePackageManifest, ProcessLauncher, type QueryResult, type ReplyInput, RequestEvent, STANDARD_ACTION_NAMES, type SendMessageParams, ServiceContainer, type StandardActionMap, type StandardInterfaceDescriptor, type StartOptions, TokenAuth, type TokenPayload, buildEventLog, buildSendMessageLog, command, compose, createApp, createAuthMiddleware, createConsoleAdapter, createErrorResponse, createStandardActions, createSuccessResponse, defineApp, definePlugin, extractMessageText, extractToken, formatMessageContent, formatMessageSegment, getCurrentApp, getFrameworkServices, initConfig, isAPIError, launch, logService, logger, normalizeEventPayload, normalizeMessageContent, normalizeMessageSegment, plumeDefaultConfig, registerStandardActions, renderMessageSegment, segment, start, stop };