interface DeviceInfo {
    appName: string;
    appVersion: string;
    deviceId: string;
    scheme: string;
    duid?: string;
    ssid?: string;
    uuid?: string;
    network?: string;
    sysModel?: string;
    sysVersion?: string;
    extraData: Record<string, string | number | boolean>;
}

interface UserInfo {
    token: string;
    userId: string;
    userName: string;
}

interface ShareConfig {
    miniprogram: [
        {
            miniprogramType: 0 | 1 | 2;
            path: string;
            title: string;
            des: string;
            userName: string;
            hdImageData: string;
            iconUrl: string;
            iconBase64String: string;
            iconName: string;
        }
    ];
    copy: {
        iconUrl: string;
        iconName: string;
        url: string;
    };
}

declare enum OpenWebViewEnum {
    Append = "Append",
    Replace = "Replace",
    Single = "Single"
}

declare enum WebViewTypeEnum {
    WebView = "WebKit",
    WKWebview = "WKWebview",
    UIWebview = "UIWebview",
    Browser = "Browser",
    WeChatMPWebView = "WxMiniProgramWebView",
    Unsupported = "Unsupported"
}

declare enum OrientationEnum {
    Landscape = "Landscape",
    Portrait = "Portrait"
}
interface WebViewErrorInfo {
    errorCode: string;
    errorMsg: string;
}
interface WebViewState {
    active: boolean;
    orientation: OrientationEnum;
    minimized: boolean;
}

type WebViewEventMap = {
    'error'(error: Error | WebViewErrorInfo): void;
    'webViewStateChange': (webViewState: WebViewState) => void;
};

type EventMap = {
    [name: string]: (...args: any[]) => void | boolean;
};
declare class Subscribe<T extends EventMap> {
    hasListener(name: keyof T): boolean;
    on<K extends keyof T>(name: K, callback: (...args: Parameters<T[K]>) => ReturnType<T[K]>, once?: boolean): () => void;
    once<K extends keyof T>(name: K, callback: (...args: Parameters<T[K]>) => ReturnType<T[K]>): () => void;
    off<K extends keyof T>(name?: K, callback?: (...args: Parameters<T[K]>) => ReturnType<T[K]>): void;
    emit<K extends keyof T>(name: K, ...data: Parameters<T[K]>): boolean;
}

interface StaticData extends DeviceInfo {
    userInfo?: UserInfo;
    [key: string]: unknown;
}

type JSBridgeReturnType<T> = [T | null, Error | null];
interface JSBridgeProtocol extends Subscribe<WebViewEventMap> {
    webViewType: WebViewTypeEnum;
    ready(): Promise<JSBridgeReturnType<boolean>>;
    callAndBackfeed<T>(schemeUrl: string): Promise<JSBridgeReturnType<T | false>>;
    callAndListen<T>(schemeUrl: string, callback: (data: T) => void): Promise<JSBridgeReturnType<false | (() => void)>>;
    loadProgress(progress: number): Promise<JSBridgeReturnType<boolean>>;
    closeLoading(): Promise<JSBridgeReturnType<boolean>>;
    getDeviceInfo(): Promise<JSBridgeReturnType<DeviceInfo | false>>;
    getStaticData(): Promise<JSBridgeReturnType<StaticData | false>>;
    getWebViewState(): Promise<JSBridgeReturnType<WebViewState | false>>;
    setLeftTopBackButton(enable: boolean): Promise<JSBridgeReturnType<boolean>>;
    login(): Promise<JSBridgeReturnType<UserInfo | false>>;
    logout(): Promise<JSBridgeReturnType<boolean>>;
    getUserInfo(): Promise<JSBridgeReturnType<UserInfo | false>>;
    openWebView(url: string, way: OpenWebViewEnum): Promise<JSBridgeReturnType<boolean>>;
    closeWebView(): Promise<JSBridgeReturnType<boolean>>;
    getBangsHeight(): Promise<JSBridgeReturnType<number | false>>;
    setOrientation(orientation: OrientationEnum): Promise<JSBridgeReturnType<boolean>>;
    keepScreenLight(enable: boolean): Promise<JSBridgeReturnType<boolean>>;
    shock(duration?: number): Promise<JSBridgeReturnType<boolean>>;
    minimize(): Promise<JSBridgeReturnType<boolean>>;
    saveImage2Album(base64: string): Promise<JSBridgeReturnType<boolean>>;
    detectMicro(): Promise<JSBridgeReturnType<boolean>>;
    actionShare(shareConfig: Partial<ShareConfig>): Promise<JSBridgeReturnType<boolean>>;
    preload(urls: string[]): Promise<JSBridgeReturnType<boolean>>;
    createCacheProxyUrl(urls: string | string[]): string[];
    invokeNativeApi?<P extends any, R extends any>(method: string, data?: P): R | Promise<R>;
}

interface ControllerProtocol {
    checkReady(timeout?: number): Promise<JSBridgeReturnType<boolean>>;
    getStaticData(timeout?: number): Promise<JSBridgeReturnType<StaticData | false>>;
    callAndBackfeed<T>(scheme: string): Promise<JSBridgeReturnType<false | T>>;
    callAndListen<T>(scheme: string, callback: (data: T) => void): Promise<JSBridgeReturnType<false | (() => void)>>;
}

declare class BaseController implements ControllerProtocol {
    checkReady(timeout?: number): Promise<JSBridgeReturnType<boolean>>;
    getStaticData(timeout?: number): Promise<JSBridgeReturnType<StaticData | false>>;
    callAndBackfeed<T>(scheme: string): Promise<JSBridgeReturnType<false | T>>;
    callAndListen<T>(scheme: string, callback: (data: T) => void): Promise<JSBridgeReturnType<false | (() => void)>>;
}

interface HybridBridgeLJ {
    getStaticData: (functionName: string) => void;
    callAndBackfeed: (msg: string) => void;
    callAndListen: (msg: string) => void;
    invoke?<P, R>(method: string, args: P): Promise<R>;
    execute?<P, R>(method: string, args: P): Promise<R>;
    isReady: boolean;
}
declare class HybridBridge implements HybridBridgeLJ {
    private _rsWeappBridgeMethodAdapter;
    private _ws;
    private _readyState;
    get isReady(): boolean;
    constructor();
    initialize: (timeout?: number) => Promise<JSBridgeReturnType<boolean>>;
    private initBuiltInHandlers;
    private _open;
    private _registerLifecycleHandler;
    private _registerHeartbeatHandler;
    private _receivedMessage;
    private _registerReadyHandler;
    send: (data: string | ArrayBufferLike | Blob | ArrayBufferView) => void;
    waitReady: (timeout?: number) => Promise<boolean>;
    private _parseMessage;
    private _registerMessageHandler;
    private _registerBridgeRequestHandler;
    getStaticData: (callbackFunctionName: string) => void;
    private _callAndBackfeed;
    callAndBackfeed: (msg: string) => void;
    private _callAndListen;
    callAndListen: (msg: string) => void;
    invoke<P, R>(method: string, args: P): Promise<R>;
    execute: <P = any, R = any>(method: string, args?: P | undefined) => Promise<R>;
    private _invokeBridgeMethod;
}

declare class WxMiniprogramController extends BaseController {
    private _hybridBridge;
    deviceInfo?: DeviceInfo;
    staticData?: StaticData;
    initializing: boolean;
    get hybridBridge(): HybridBridge;
    private checkBridgeReady;
    checkReady(timeout?: number): Promise<JSBridgeReturnType<boolean>>;
    getStaticData(timeout?: number): Promise<JSBridgeReturnType<StaticData | false>>;
    get ready(): boolean;
    get scheme(): string;
    createSchemeLink(schemeUrl: string): string;
    callAndBackfeed<T>(scheme: string): Promise<JSBridgeReturnType<false | T>>;
    callAndListen<T>(scheme: string, callback: (data: T) => void): Promise<JSBridgeReturnType<false | (() => void)>>;
    invoke<P, R>(method: string, data?: P): Promise<R>;
}

declare abstract class JSBridgeCore extends Subscribe<WebViewEventMap> implements JSBridgeProtocol {
    webViewType: WebViewTypeEnum;
    abstract ready(): Promise<JSBridgeReturnType<boolean>>;
    abstract callAndBackfeed<T>(schemeUrl: string): Promise<JSBridgeReturnType<false | T>>;
    abstract callAndListen<T>(schemeUrl: string, callback: (data: T) => void): Promise<JSBridgeReturnType<false | (() => void)>>;
    abstract loadProgress(progress: number): Promise<JSBridgeReturnType<boolean>>;
    abstract closeLoading(): Promise<JSBridgeReturnType<boolean>>;
    abstract getDeviceInfo(): Promise<JSBridgeReturnType<false | DeviceInfo>>;
    abstract getStaticData(): Promise<JSBridgeReturnType<false | StaticData>>;
    abstract getWebViewState(): Promise<JSBridgeReturnType<false | WebViewState>>;
    abstract setLeftTopBackButton(enable: boolean): Promise<JSBridgeReturnType<boolean>>;
    abstract login(): Promise<JSBridgeReturnType<false | UserInfo>>;
    abstract logout(): Promise<JSBridgeReturnType<boolean>>;
    abstract getUserInfo(): Promise<JSBridgeReturnType<false | UserInfo>>;
    abstract openWebView(url: string, way: OpenWebViewEnum): Promise<JSBridgeReturnType<boolean>>;
    abstract closeWebView(): Promise<JSBridgeReturnType<boolean>>;
    abstract getBangsHeight(): Promise<JSBridgeReturnType<number | false>>;
    abstract setOrientation(orientation: OrientationEnum): Promise<JSBridgeReturnType<boolean>>;
    abstract keepScreenLight(enable: boolean): Promise<JSBridgeReturnType<boolean>>;
    abstract shock(duration?: number): Promise<JSBridgeReturnType<boolean>>;
    abstract minimize(): Promise<JSBridgeReturnType<boolean>>;
    abstract saveImage2Album(base64: string): Promise<JSBridgeReturnType<boolean>>;
    abstract detectMicro(): Promise<JSBridgeReturnType<boolean>>;
    abstract actionShare(shareConfig: Partial<ShareConfig>): Promise<JSBridgeReturnType<boolean>>;
    abstract preload(urls: string[]): Promise<JSBridgeReturnType<boolean>>;
    abstract createCacheProxyUrl(urls: string | string[]): string[];
}

interface JSBridgeOptions {
    timeout?: number;
    wsOrigin?: string;
}

declare class JSBridgeMiniprogram extends JSBridgeCore {
    options: JSBridgeOptions & {
        wsOrigin?: string;
    };
    _controller: WxMiniprogramController;
    webViewType: WebViewTypeEnum;
    constructor(options?: Partial<JSBridgeOptions>);
    ready(): Promise<JSBridgeReturnType<boolean>>;
    callAndBackfeed<T>(schemeUrl: string): Promise<JSBridgeReturnType<false | T>>;
    callAndListen<T>(schemeUrl: string, callback: (data: T) => void): Promise<JSBridgeReturnType<false | (() => void)>>;
    setLeftTopBackButton(enable?: boolean): Promise<JSBridgeReturnType<boolean>>;
    getBangsHeight(): Promise<JSBridgeReturnType<number | false>>;
    shock(duration?: number): Promise<JSBridgeReturnType<boolean>>;
    minimize(): Promise<JSBridgeReturnType<boolean>>;
    loadProgress(progress: number): Promise<JSBridgeReturnType<boolean>>;
    closeLoading(): Promise<JSBridgeReturnType<boolean>>;
    setOrientation(orientation: OrientationEnum): Promise<JSBridgeReturnType<boolean>>;
    keepScreenLight(enable: boolean): Promise<JSBridgeReturnType<boolean>>;
    closeWebView(): Promise<JSBridgeReturnType<boolean>>;
    openWebView(url: string, way: OpenWebViewEnum): Promise<JSBridgeReturnType<boolean>>;
    saveImage2Album(base64: string): Promise<JSBridgeReturnType<boolean>>;
    actionShare(shareConfig: Partial<ShareConfig>): Promise<JSBridgeReturnType<boolean>>;
    getDeviceInfo(): Promise<JSBridgeReturnType<false | DeviceInfo>>;
    getStaticData(): Promise<JSBridgeReturnType<StaticData | false>>;
    getUserInfo(): Promise<JSBridgeReturnType<false | UserInfo>>;
    getWebViewState(): Promise<JSBridgeReturnType<false | WebViewState>>;
    login(): Promise<JSBridgeReturnType<false | UserInfo>>;
    logout(): Promise<JSBridgeReturnType<boolean>>;
    detectMicro(): Promise<JSBridgeReturnType<boolean>>;
    preload(urls: string[]): Promise<JSBridgeReturnType<boolean>>;
    createCacheProxyUrl(urls: string | string[]): string[];
    invokeNativeApi<P, R>(method: string, data?: P): Promise<R>;
    execute(method: string, args?: any): Promise<any>;
}

export { JSBridgeMiniprogram };