declare type AnyFunction = (...args: any[]) => any;

declare type AnyObject = Record<any, any>;

export declare const channelGenerator: (controller: string, event: string, type: ChannelTypes) => string;

declare type ChannelTypes = 'c' | 'i' | 's';

declare type ClientFunctionReturnType<T extends AnyFunction = AnyFunction> = Promise<Awaited<ReturnType<T>>>;

export declare function createIpcClient<Functions extends AnyObject = any, ClientEvents extends AnyObject = any, ServerEvents extends AnyObject = any>(...args: ConstructorParameters<typeof IpcClientController>): IpcClientController<Functions, ClientEvents, ServerEvents> & IpcClientControllerProxy<Functions>;

export declare function createIpcServer<Functions extends AnyObject = any, ClientEvents extends AnyObject = any, ServerEvents extends AnyObject = any>(...args: ConstructorParameters<typeof IpcServerController>): IpcServerController<Functions, ClientEvents, ServerEvents>;

/**
 * The error handler defaults to using the [serialize-error]{@link https://www.npmjs.com/package/serialize-error}
 * package to serialize and deserialize error objects.
 *
 * The serialize method must be defined in the main process and the
 * deserialize method must be defined in the renderer process.
 */
export declare const ErrorHandler: ErrorHandlerInterface;

declare interface ErrorHandlerInterface {
    serialize(error: any): object;
    deserialize(errorObject: any): Error;
}

declare type ExactType<T, U> = [T] extends [U] ? ([U] extends [T] ? true : false) : false;

declare type FunctionParameters<T> = T extends AnyFunction ? Parameters<T> : any[];

declare type FunctionProperties<T> = T extends AnyObject ? Extract<keyof Pick<T, FunctionPropertyNames<T>>, string> : string;

declare type FunctionPropertyNames<T> = {
    [K in keyof T]: T[K] extends AnyFunction ? K : never;
}[keyof T];

export declare interface InitOptions {
    /**
     * Auto register `IpcClientController`, default is `true`.
     *
     * If you do not use it, you need to manually call {@link IpcClientController.register} in the preload script.
     *
     * If you want to strictly control which IPC each renderer can use, you can disable auto register.
     */
    autoRegister?: boolean;
    /**
     * If the value is greater than 0, use `contextBridge.exposeInIsolatedWorld` to
     * expose the global object in isolated world.
     */
    isolatedWorldId?: number;
}

/**
 * Controller used in the renderer process
 */
export declare class IpcClientController<Functions extends AnyObject, ClientEvents extends AnyObject, ServerEvents extends AnyObject> {
    #private;
    /**
     * @param name {string} Controller name
     */
    constructor(name: string);
    /**
     * Controller name
     */
    get name(): string;
    /**
     * Use `ipcRenderer.invoke()` to call the function defined by `IpcServerController.handle()`.
     */
    invoke<K extends FunctionProperties<Functions>>(name: K, ...args: FunctionParameters<Functions[K]>): ClientFunctionReturnType<Functions[K]>;
    postMessage<K extends FunctionProperties<ServerEvents>>(event: K, message: any, transfer?: MessagePort[]): void;
    /**
     * Removes event listeners added using `on()` and `once()`.
     *
     * If the `listener` parameter is not provided, all listeners for
     * the corresponding event will be removed.
     */
    off<K extends FunctionProperties<ClientEvents>>(event: K, listener?: RendererEventListener<ClientEvents[K]>): void;
    /**
     * Adds a specific client event listener, where the first parameter of
     * the listener is of type `Electron.IpcRendererEvent`.
     */
    on<K extends FunctionProperties<ClientEvents>>(event: K, listener: RendererEventListener<ClientEvents[K]>): void;
    /**
     * Like `on()`, but the listener is removed after it is triggered once.
     *
     * @see {on}
     */
    once<K extends FunctionProperties<ClientEvents>>(event: K, listener: RendererEventListener<ClientEvents[K]>): void;
    /**
     * Uses `ipcRenderer.send()` to send to the server event listeners added with `IpcServerController.on()`.
     */
    send<K extends FunctionProperties<ServerEvents>>(event: K, ...args: FunctionParameters<ServerEvents[K]>): void;
    /**
     * If auto register is not enabled, use this method in the
     * **preload script** to manually register the controller.
     */
    register(): void;
    /**
     * Can use this method in the **preload script** to unregister the controller
     */
    unregister(): void;
}

declare type IpcClientControllerProxy<T extends AnyObject> = {
    [K in FunctionProperties<T> as `\$${K}`]: T[K] extends AnyFunction ? (...args: FunctionParameters<T[K]>) => ClientFunctionReturnType<T[K]> : never;
};

declare type IpcEventListener<T extends Electron.Event, K extends AnyFunction = AnyFunction> = (event: T, ...args: FunctionParameters<K>) => ExactType<T, Electron.IpcMainInvokeEvent> extends true ? ReturnType<K> : void;

/**
 * Controller used in the main process
 */
export declare class IpcServerController<Functions extends AnyObject, ClientEvents extends AnyObject, ServerEvents extends AnyObject> {
    #private;
    /**
     * `IpcServerController` calls the trust handler when it receives a call or event.
     * If the trust handler returns false, an exception is thrown to the renderer process: "*Blocked by trust handler.*".
     *
     *
     * @see {trustHandler}
     */
    static TrustHandler: TrustHandlerFunc<ReturnType<typeof createIpcServer>>;
    /**
     * Used to specify which renderers the `IpcServerController.send` method sends events to.
     * by default, it does not send to any renderers.
     *
     * @see {webContentsGetter}
     */
    static WebContentsGetter: WebContentsGetterFunc | undefined;
    /**
     * `Electron.IpcMain` used by all IpcServerController instances.
     *
     * @see {Electron.IpcMain}
     */
    static IpcMain: Electron.IpcMain | undefined;
    /**
     * `Electron.IpcMain` used by this instance.
     *
     * @see {Electron.IpcMain}
     * @see {IpcServerController.IpcMain}
     */
    ipcMain: Electron.IpcMain | undefined;
    /**
     * This controller specific trust handler.
     *
     * @see {TrustHandler}
     */
    trustHandler: TrustHandlerFunc<this> | undefined;
    /**
     * This controller specific webContents getter.
     *
     * @see {WebContentsGetter}
     */
    webContentsGetter: WebContentsGetterFunc | undefined;
    /**
     * @param name {string} Controller name
     */
    constructor(name: string);
    /**
     * Controller name
     */
    get name(): string;
    /**
     * Use the `handle()` to set all properties of an object as function handlers, with the
     * property names being used as function names.
     *
     * If the value is set to `undefined` or if the property has been set previously, the
     * existing function handler will be removed using `removeHandler()` first.
     *
     * @see {handle}
     * @see {removeHandler}
     */
    set handlers(value: Partial<Functions> | undefined);
    /**
     * Uses `IpcMain.handle()` to add a specific function handler.
     */
    handle<K extends FunctionProperties<Functions>>(name: K, handler: Functions[K]): void;
    /**
     * Like `handle()`, it will just pass the event object.
     *
     * @see {handle}
     */
    handleWithEvent<K extends FunctionProperties<Functions>>(name: K, handler: MainInvokeEventHandler<Functions[K]>): void;
    /**
     * Uses `IpcMain.removeHandler()` to remove a specific function handler.
     */
    removeHandler<K extends FunctionProperties<Functions>>(name: K): void;
    /**
     * Removes event listeners added using `on()` and `once()`.
     *
     * If the `listener` parameter is not provided, all listeners for
     * the corresponding event will be removed.
     */
    off<K extends FunctionProperties<ServerEvents>>(event: K, listener?: MainEventListener<ServerEvents[K]>): void;
    /**
     * Adds a specific server event listener, where the first parameter of
     * the listener is of type `Electron.IpcMainEvent`.
     */
    on<K extends FunctionProperties<ServerEvents>>(event: K, listener: MainEventListener<ServerEvents[K]>): void;
    /**
     * Like `on()`, but the listener is removed after it is triggered once.
     *
     * @see {on}
     */
    once<K extends FunctionProperties<ServerEvents>>(event: K, listener: MainEventListener<ServerEvents[K]>): void;
    /**
     * Uses `WebContents.send()` to send to the server event listeners added with `IpcClientController.on()`.
     */
    send<K extends FunctionProperties<ClientEvents>>(event: K, ...args: FunctionParameters<ClientEvents[K]>): void;
    /**
     * Like `send()`, but use `WebContents.sendToFrame()`.
     *
     * @see {send}
     */
    sendToFrame<K extends FunctionProperties<ClientEvents>>(frameId: number | [number, number], event: K, ...args: FunctionParameters<ClientEvents[K]>): void;
}

declare type MainEventListener<T extends AnyFunction = AnyFunction> = IpcEventListener<Electron.IpcMainEvent, T>;

declare type MainInvokeEventHandler<T extends AnyFunction> = IpcEventListener<Electron.IpcMainInvokeEvent, T>;

/**
 * Initialize the required global objects (must be called in the preload script).
 */
export declare function preloadInit(contextBridge: Electron.ContextBridge, ipcRenderer: Electron.IpcRenderer, options?: InitOptions): void;

declare type RendererEventListener<T extends AnyFunction = AnyFunction> = IpcEventListener<Electron.IpcRendererEvent, T>;

declare type TrustHandlerFunc<Controller extends IpcServerController<any, any, any>> = {
    (controller: Controller, name: Parameters<Controller['on']>[0], type: 'event', event: Electron.IpcMainEvent): Promise<boolean> | boolean;
    (controller: Controller, name: Parameters<Controller['handle']>[0], type: 'invoke', event: Electron.IpcMainInvokeEvent): Promise<boolean> | boolean;
};

declare type WebContentsGetterFunc = () => Promise<Electron.WebContents[]> | Electron.WebContents[];

export { }