import { ViteHotContext } from 'vite-hot-client';
import { BirpcReturn } from 'birpc';
import { EventType, Handler } from 'mitt-kesplus';

declare enum BridgeEvents {
    FILE_CONTENT_CHANGE = "file_content_change",
    ERROR = "error",
    UPDATE = "update"
}
interface BridgeAdapterOptions {
    tracker: (fn: Function) => void;
    trigger: (data: Record<string, any>) => void;
}
type BridgeInstanceType = InstanceType<typeof Bridge>;
declare const bridgeRpcEvents: {
    readonly routerInfo: "router-info";
    readonly router: "router";
    readonly routeMatched: "route-matched";
    readonly openInEditor: "open-in-editor";
};
type BridgeRpcEvents = typeof bridgeRpcEvents;
type BridgeRpcEventName = BridgeRpcEvents[keyof BridgeRpcEvents];
interface BridgeRpcEventPayload {
    [bridgeRpcEvents.routerInfo]: null;
    [bridgeRpcEvents.router]: string;
    [bridgeRpcEvents.routeMatched]: string;
    [bridgeRpcEvents.openInEditor]: string;
}
declare class Bridge<Events extends Record<EventType, any>, Key extends keyof Events> {
    private emitter;
    private adapter;
    constructor(adapter?: BridgeAdapterOptions);
    private _on;
    private off;
    private _emit;
    on(eventName: Key, handler: Handler<Events[Key]>): () => void;
    once(eventName: Key, handler: Handler<Events[Key]>): void;
    emit(eventName: Key, data?: any): void;
    removeAllListeners(): void;
}
declare class BridgeRpcCore {
    bridge: BridgeInstanceType;
    constructor(_bridge: BridgeInstanceType);
    on<E extends BridgeRpcEventName>(eventName: E, handler: (payload?: BridgeRpcEventPayload[E]) => Promise<boolean | string | void> | string): void;
    emit<S, E extends BridgeRpcEventName = BridgeRpcEventName>(eventName: E, payload?: BridgeRpcEventPayload[E]): Promise<S>;
}

type Assert = any;
interface Loc {
    line: number;
    column: number;
    offset: number;
}
interface Mometa {
    id: string;
    start: Partial<Loc>;
    end: Partial<Loc>;
    innerStart: Partial<Loc>;
    innerEnd: Partial<Loc>;
    isSelfClosing: boolean;
    filename: string;
    slotName?: string;
    parentId?: string;
    name: string;
    hash?: string;
    assert?: Assert['data']['dependencies'];
    npm?: Assert['data']['dependencies'];
}

declare enum CommandType {
    CLONE_NODE = "CLONE_NODE",
    REMOVE_NODE = "REMOVE_NODE",
    OPEN_IN_EDITOR = "OPEN_IN_EDITOR",
    FINE_DEFINITION = "FINE_DEFINITION",
    APPEND_NODE = "APPEND_NODE",
    PREPEND_NODE = "PREPEND_NODE",
    INSERT_AFTER = "INSERT_AFTER",
    INSERT_BEFORE = "INSERT_BEFORE",
    UPDATE_NODE_PROPS = "UPDATE_NODE_PROPS",
    UPDATE_NODE_CONTENT = "UPDATE_NODE_CONTENT",
    READ_NODE_CONTENT = "READ_NODE_CONTENT",
    REPLACE_NODE = "REPLACE_NODE",
    HISTORY = "HISTORY"
}
interface Command {
    type: CommandType;
    preload: {
        normalize?: boolean;
        filename: string;
        sources: (Mometa & {
            code?: string;
            dependencies?: any[];
        })[];
        target: Mometa & {
            dependencies?: any[];
        };
        text: string;
        properties: string[];
        data: Record<string, any>;
    };
}

/**
 * 定义所有前端可以调用的函数
 */
interface ViteRPCFunctions {
    root(): string;
    registerPlaceholderTag(tagName: string): void;
    handleFileOperation(payload: Command): void;
    openInEditor(payload: Mometa): void;
    findDefinition(payload: any): any[];
    readNodeContent(payload: Mometa): {
        props: any;
        content: string;
    };
    patchNodeProps(payload: Mometa, formData: any): void;
}
interface ViteRPCClientFunctions {
    fileContentChange?: (payload: string) => void;
    error?: (payload: any) => void;
}
declare function setupViteRPCClient(ctx: ViteHotContext | undefined): BirpcReturn<ViteRPCFunctions, unknown>;
interface BridgeRpcOptions {
    viteRPCContext: ViteHotContext | undefined;
    bridge: BridgeInstanceType;
}
declare function registerBridgeRpc(options: BridgeRpcOptions): Promise<void>;
/**
 * 绑定 vite websocket 抛出的事件，监听函数加类型
 * @param viteRPCContext
 */
declare function eventsMapper(viteRPCContext: ViteHotContext): void;
declare class BridgeRpc {
    static on: {
        fileContentChange(effect: (fileInfo: {
            filename: string;
            version: number;
            fileContent: string;
        }) => void): void;
        error(effect: (error: any) => void): void;
        update(effect: (payload: any) => void): void;
    };
    static readNodeContent(payload: Mometa): Promise<{
        props: any;
        content: string;
    }>;
    static patchNodeProps(payload: Mometa, formData: any): Promise<void>;
    static openInEditor(payload: Mometa): Promise<void>;
    static fileOperation(preload: Command): Promise<void>;
    static registerPlaceholderTag(tagName: string): Promise<void>;
    static findDefinition(): Promise<void>;
    static root(): Promise<string>;
}

export { Bridge, BridgeEvents, BridgeRpc, BridgeRpcCore, type BridgeRpcOptions, type ViteRPCClientFunctions, type ViteRPCFunctions, bridgeRpcEvents, eventsMapper, registerBridgeRpc, setupViteRPCClient };