import { Config } from "./config";
import { Action } from "./action";
import { OneBot, OneBotStatus } from "../../onebot";
import { Logger } from "log4js";
import { WebSocket, WebSocketServer } from "ws";
import { Dispose } from "../../types";
import { Service } from "../../service";
import { Dict } from "@zhinjs/shared";
import { JsonDB } from "../../db";
export declare class V11 extends Service<"V11"> implements OneBot.Base {
    oneBot: OneBot;
    config: OneBot.Config<"V11">;
    action: Action;
    version: OneBot.Version;
    protected timestamp: number;
    protected heartbeat?: NodeJS.Timeout;
    db: JsonDB;
    disposes: Dispose[];
    protected _queue: Array<{
        method: keyof Action;
        args: any[];
    }>;
    protected queue_running: boolean;
    logger: Logger;
    wss?: WebSocketServer;
    wsr: Set<WebSocket>;
    constructor(oneBot: OneBot, config: OneBot.Config<"V11">);
    transformToInt(path: string, value: string): number;
    transformStrToIntForObj<T extends object>(obj: T, keys: (keyof T)[]): void;
    getStrByInt(path: string, value: number): string;
    start(): void;
    private startHttp;
    private startHttpReverse;
    private startWs;
    private startWsReverse;
    stop(force?: boolean): Promise<void>;
    format(_: any, data: any): any;
    dispatch(data: any): Promise<void>;
    private _formatEvent;
    private getReplyMsgIdFromDB;
    private _httpRequestHandler;
    /**
     * 处理ws消息
     */
    protected _webSocketHandler(ws: WebSocket): void;
    /**
     * 创建反向ws
     */
    protected _createWsr(url: string): void;
    /**
     * 快速操作
     */
    protected _quickOperate(event: any, res: any): void;
    /**
     * 调用api
     */
    apply(req: V11.Protocol): Promise<string>;
    /**
     * 限速队列调用
     */
    _runQueue(): Promise<void>;
}
export declare namespace V11 {
    interface Result<T extends any> {
        retcode: number;
        status: "ok" | "async" | "error";
        data: T;
        error: string;
        msg?: string;
        wording?: string;
        echo?: string;
    }
    function ok<T extends any>(data: T, retcode?: number, pending?: boolean, echo?: string): Result<T>;
    function error(error: string, echo?: string, retcode?: number, wording?: string): Result<any>;
    const defaultConfig: Config;
    function genMetaEvent(uin: string, type: string): {
        self_id: string | number;
        time: number;
        post_type: string;
        meta_event_type: string;
        sub_type: string;
    };
    interface Protocol {
        action: string;
        params: any;
        echo?: any;
    }
    interface Config {
        access_token?: string;
        post_timeout?: number;
        enable_cors?: boolean;
        enable_reissue?: boolean;
        rate_limit_interval?: number;
        post_message_format?: "string" | "array";
        heartbeat?: number;
        secret?: string;
        reconnect_interval?: number;
        use_http?: boolean;
        use_ws?: boolean;
        http_reverse?: (string | Config.HttpReverseConfig)[];
        ws_reverse?: string[];
    }
    type Payload<T = Dict> = {
        [P in string | symbol]: any;
    } & T;
    type SelfInfo = {
        status: OneBotStatus;
        nickname: string;
    };
    interface GroupInfo {
        group_id: number;
        group_name: string;
    }
    interface UserInfo {
        user_id: number;
        user_name: string;
    }
    interface GroupMemberInfo {
        group_id: number;
        user_id: number;
        user_name: string;
    }
    interface Segment {
        type: string;
        data: Dict;
    }
    type Sendable = string | Segment | (string | Segment)[];
    interface Message {
        message: Sendable;
    }
    type MessageNode = {
        content: Sendable;
    } & ({
        uin: number;
        user_id: never;
        name: string;
        nickname: never;
    } | {
        user_id: number;
        uin: never;
        nickname: string;
        name: never;
    });
    interface MessageRet {
        message_id: number;
    }
}