@overlayed/app 0.10.1 → 0.11.0

package/dist/index.d.ts

@@ -1,32 +1,35 @@
 /// <reference types="electron" />
 /// <reference types="node" />
 
-import { BrowserWindow } from 'electron';
-import { electron } from 'electron';
-import { Module } from 'arktype';
-import { ObjectType } from 'arktype/internal/methods/object.ts';
-import { Out } from 'arktype/internal/attributes.ts';
-import { Process } from '@overlayed-gg/native-interface';
+import { BrowserWindow } from "electron";
+import { electron } from "electron";
+import { Module } from "arktype";
+import { ObjectType } from "arktype/internal/methods/object.ts";
+import { Out } from "arktype/internal/attributes.ts";
+import { Process } from "@overlayed-gg/native-interface";
 
 export const enum AccessLevel {
-    		Default = 0,
-    		Global = 1,
-    		Admin = 2,
-    	}
+	Default = 0,
+	Global = 1,
+	Admin = 2,
+}
 
 export declare type ActiveGameInfo = {
-    isConnected: boolean;
-    resolution: {
-        width: number;
-        height: number;
-    };
+	isConnected: boolean;
+	resolution: {
+		width: number;
+		height: number;
+	};
 };
 
-declare const BaseEvent: ObjectType<    {
-game: string;
-type: string;
-creation_time: number;
-}, {}>;
+declare const BaseEvent: ObjectType<
+	{
+		game: string;
+		type: string;
+		creation_time: number;
+	},
+	{}
+>;
 
 declare type BaseEvent = typeof BaseEvent.infer;
 
@@ -58,107 +61,100 @@ declare type BaseEvent = typeof BaseEvent.infer;
  * ```
  */
 declare type Brand<Base, Branding, ReservedName extends string = "__type__"> = Base & {
-    	[K in ReservedName]: Branding;
+	[K in ReservedName]: Branding;
 } & { __witness__: Base };
 
-declare interface CortexEvents extends Record<string, unknown> {
-}
+declare interface CortexEvents extends Record<string, unknown> {}
 
-declare interface CortexLogs extends Record<string, unknown> {
-}
+declare interface CortexLogs extends Record<string, unknown> {}
 
 declare type CustomLoggerScope = ReturnType<typeof Logger.prototype.scope>;
 
 declare type ErrorEvents = ErrorPipeServerError | ErrorInvalidConfigFile;
 
 declare interface ErrorInvalidConfigFile extends ErrorManagerEvent {
-    	code: "INVALID_CONFIG_FILE";
-    	data: {
-        		issues: string[];
-        		filePath: string;
-        		data: unknown;
-        	};
+	code: "INVALID_CONFIG_FILE";
+	data: {
+		issues: string[];
+		filePath: string;
+		data: unknown;
+	};
 }
 
 declare type ErrorManagerEvent = {
-    	code: string;
-    	message: string;
-    	data: Record<string, any>;
-    	timestamp: number;
+	code: string;
+	message: string;
+	data: Record<string, any>;
+	timestamp: number;
 };
 
 declare type ErrorManagerEvents = {
-    	fatal: FatalEvents;
-    	error: ErrorEvents;
-    	warning: WarningEvents;
+	fatal: FatalEvents;
+	error: ErrorEvents;
+	warning: WarningEvents;
 };
 
 declare interface ErrorPipeServerError extends ErrorManagerEvent {
-    	code: "PIPE_SERVER_ERROR";
-    	data: {
-        		error: unknown;
-        	};
+	code: "PIPE_SERVER_ERROR";
+	data: {
+		error: unknown;
+	};
 }
 
-declare type EventCallback<TEvent extends BaseEvent, TEventType extends EventType<TEvent>> = (event: Extract<TEvent, {
-    type: TEventType;
-}>) => void;
+declare type EventCallback<TEvent extends BaseEvent, TEventType extends EventType<TEvent>> = (
+	event: Extract<
+		TEvent,
+		{
+			type: TEventType;
+		}
+	>,
+) => void;
 
 declare type EventType<TEvent extends BaseEvent> = TEvent["type"];
 
 declare interface FatalElevationMismatch extends ErrorManagerEvent {
-    	code: "ELEVATION_MISMATCH";
-    	data: {
-        		appElevated: boolean;
-        		gameElevated: boolean;
-        	};
+	code: "ELEVATION_MISMATCH";
+	data: {
+		appElevated: boolean;
+		gameElevated: boolean;
+	};
 }
 
 declare type FatalEvents = FatalElevationMismatch;
 
 export declare type GameLaunchManagerEvents = {
-    gameCloseInternal: (args: {
-        ravenGame: GameModel;
-        process: Process;
-    }) => MaybePromise<void>;
-    gameLaunch: (args: {
-        game: string;
-        reject: () => void;
-    }) => MaybePromise<boolean>;
-    gameClose: (args: {
-        game: string;
-    }) => MaybePromise<void>;
-    gameReady: (args: {
-        game: string;
-    }) => MaybePromise<void>;
-    gameReadyInternal: (args: {
-        ravenGame: GameModel;
-        process: Process;
-    }) => MaybePromise<void>;
+	gameCloseInternal: (args: { ravenGame: GameModel; process: Process }) => MaybePromise<void>;
+	gameLaunch: (args: { game: string; reject: () => void }) => MaybePromise<boolean>;
+	gameClose: (args: { game: string }) => MaybePromise<void>;
+	gameReady: (args: { game: string }) => MaybePromise<void>;
+	gameReadyInternal: (args: { ravenGame: GameModel; process: Process }) => MaybePromise<void>;
 };
 
 declare interface GameModel {
-    name: string;
-    identifier: Brand<string, GameModel>;
-    modules: string[];
-    executables: string[];
+	name: string;
+	identifier: Brand<string, GameModel>;
+	modules: string[];
+	executables: string[];
 }
 
-declare interface GameModule<TEvents extends Record<string, BaseEvent> = Record<string, BaseEvent>, TKey extends string = string> {
-    key: TKey;
-    events: Module<GameModuleEvent<TEvents>>;
+declare interface GameModule<
+	TEvents extends Record<string, BaseEvent> = Record<string, BaseEvent>,
+	TKey extends string = string,
+> {
+	key: TKey;
+	events: Module<GameModuleEvent<TEvents>>;
 }
 
 declare type GameModuleEvent<TEvents extends Record<string, BaseEvent>> = TEvents & {
-    event: BaseEvent;
+	event: BaseEvent;
 };
 
 declare type GameModuleEventInfer<TModule extends GameModule> = TModule["events"]["event"]["infer"];
 
 declare type KeybindCallbacks = {
-    toggle?: KeybindPressedCallback;
-    down?: KeybindDownCallback;
-    up?: KeybindUpCallback;
+	toggle?: KeybindPressedCallback;
+	down?: KeybindDownCallback;
+	up?: KeybindUpCallback;
 };
 
 export declare type KeybindConfig = (typeof KeybindSchema.infer)[string];
@@ -167,637 +163,712 @@ declare type KeybindDownCallback = () => string | void;
 
 declare type KeybindPressedCallback = () => string | void;
 
-declare const KeybindSchema: ObjectType<    {
-[x: string]: {
-keys: string[];
-mode: (In: "toggle" | "hold") => Out<"toggle" | "hold">;
-};
-}, {}>;
+declare const KeybindSchema: ObjectType<
+	{
+		[x: string]: {
+			keys: string[];
+			mode: (In: "toggle" | "hold") => Out<"toggle" | "hold">;
+		};
+	},
+	{}
+>;
 
 declare type KeybindUpCallback = () => void;
 
 export interface KeyboardKeyEvent extends WindowEvent {
-    		key: VirtualKey;
-    	}
+	key: VirtualKey;
+}
 
 declare const Logger = AsSingleton(LoggerClass);
 
 /** This should be kept in sync with EventEmitterManager */
 declare class Manager {
-    protected logger: CustomLoggerScope;
-    initialized: boolean;
-    constructor(name: string);
-    init(): void;
-    destroy(): void;
+	protected logger: CustomLoggerScope;
+	initialized: boolean;
+	constructor(name: string);
+	init(): void;
+	destroy(): void;
 }
 
 declare type MaybePromise<T> = T | Promise<T>;
 
 export interface MouseButtonEvent extends WindowEvent {
-    		x: number;
-    		y: number;
-
-    		globalX: number;
-    		globalY: number;
-
-    		key: VirtualKey;
-    	}
-
-export declare function overlayed<TModule extends GameModule, TShortcut extends string>(options: OverlayedOptions<TModule, TShortcut>): OverlayedApp<TModule, TShortcut>;
-
-export declare type OverlayedApp<TModule extends GameModule, TKeybind extends string> = OverlayedAppGameModules<TModule> & OverlayedAppHandlers & {
-    keybinds: OverlayedAppKeybindModule<TKeybind>;
-    windows: OverlayedAppWindowsModule;
-    input: OverlayedAppInputModule;
-    ads: OverlayedAppAdsModule;
-    cortex: OverlayedAppCortexModule;
-    /**
-     * Returns true if any monitored processes are running.
-     *
-     * Useful for stopping the overlay from updating when the game is running.
-     */
-    hasAnyActiveProcesses: () => boolean;
-    /**
-     * Initializes the overlayed app.
-     *
-     * This should only be called once, and is automatically called by default, unless `init: false` is passed:
-     * ```ts
-     * overlayed({
-     * 	init: false,
-     * });
-     * ```
-     */
-    init: () => void;
-    /**
-     * Returns true if the overlayed app has been initialized.
-     */
-    initialized: boolean;
-};
+	x: number;
+	y: number;
+
+	globalX: number;
+	globalY: number;
+
+	key: VirtualKey;
+}
+
+export declare function overlayed<TModule extends GameModule, TShortcut extends string>(
+	options: OverlayedOptions<TModule, TShortcut>,
+): OverlayedApp<TModule, TShortcut>;
+
+export declare type OverlayedApp<
+	TModule extends GameModule,
+	TKeybind extends string,
+> = OverlayedAppGameModules<TModule> &
+	OverlayedAppHandlers & {
+		keybinds: OverlayedAppKeybindModule<TKeybind>;
+		windows: OverlayedAppWindowsModule;
+		input: OverlayedAppInputModule;
+		ads: OverlayedAppAdsModule;
+		cortex: OverlayedAppCortexModule;
+		/**
+		 * Returns true if any monitored processes are running.
+		 *
+		 * Useful for stopping the overlay from updating when the game is running.
+		 */
+		hasAnyActiveProcesses: () => boolean;
+		/**
+		 * Initializes the overlayed app.
+		 *
+		 * This should only be called once, and is automatically called by default, unless `init: false` is passed:
+		 * ```ts
+		 * overlayed({
+		 * 	init: false,
+		 * });
+		 * ```
+		 */
+		init: () => void;
+		/**
+		 * Returns true if the overlayed app has been initialized.
+		 */
+		initialized: boolean;
+	};
 
 declare interface OverlayedAppAdsModule {
-    registerWindow(window: BrowserWindow, options?: {
-        linkHandler?: {
-            allowHosts?: string[];
-        };
-    }): void;
+	registerWindow(
+		window: BrowserWindow,
+		options?: {
+			linkHandler?: {
+				allowHosts?: string[];
+			};
+		},
+	): void;
 }
 
 declare interface OverlayedAppCortexModule {
-    trackEvent: <TEventName extends keyof CortexEvents>(name: TEventName, data: CortexEvents[TEventName]) => void;
-    trackLog: <TEventName extends keyof CortexLogs>(name: TEventName, data: CortexLogs[TEventName]) => void;
+	trackEvent: <TEventName extends keyof CortexEvents>(name: TEventName, data: CortexEvents[TEventName]) => void;
+	trackLog: <TEventName extends keyof CortexLogs>(name: TEventName, data: CortexLogs[TEventName]) => void;
 }
 
 declare type OverlayedAppGameModules<TModule extends GameModule> = {
-    [TKey in TModule["key"]]: {
-        onAny<TEvent extends Extract<TModule, {
-            key: TKey;
-        }>["events"]["event"]["infer"]>(cb: (data: TEvent) => void): void;
-        on<TEvent extends Extract<TModule, {
-            key: TKey;
-        }>["events"]["event"]["infer"], TEventType extends EventType<TEvent> = EventType<TEvent>>(event: TEventType, cb: EventCallback<TEvent, TEventType>): void;
-        offAny<TEvent extends Extract<TModule, {
-            key: TKey;
-        }>["events"]["event"]["infer"]>(cb: (data: TEvent) => void): void;
-        off<TEvent extends GameModuleEventInfer<Extract<TModule, {
-            key: TKey;
-        }>>, TEventType extends EventType<TEvent> = EventType<TEvent>>(event: TEventType, cb: EventCallback<TEvent, TEventType>): void;
-    };
+	[TKey in TModule["key"]]: {
+		onAny<
+			TEvent extends Extract<
+				TModule,
+				{
+					key: TKey;
+				}
+			>["events"]["event"]["infer"],
+		>(
+			cb: (data: TEvent) => void,
+		): void;
+		on<
+			TEvent extends Extract<
+				TModule,
+				{
+					key: TKey;
+				}
+			>["events"]["event"]["infer"],
+			TEventType extends EventType<TEvent> = EventType<TEvent>,
+		>(
+			event: TEventType,
+			cb: EventCallback<TEvent, TEventType>,
+		): void;
+		offAny<
+			TEvent extends Extract<
+				TModule,
+				{
+					key: TKey;
+				}
+			>["events"]["event"]["infer"],
+		>(
+			cb: (data: TEvent) => void,
+		): void;
+		off<
+			TEvent extends GameModuleEventInfer<
+				Extract<
+					TModule,
+					{
+						key: TKey;
+					}
+				>
+			>,
+			TEventType extends EventType<TEvent> = EventType<TEvent>,
+		>(
+			event: TEventType,
+			cb: EventCallback<TEvent, TEventType>,
+		): void;
+	};
 };
 
 declare type OverlayedAppHandlers = {
-    on: <TEvent extends keyof OverlayedAppHandlersMapping = keyof OverlayedAppHandlersMapping>(event: TEvent, cb: OverlayedAppHandlersMapping[TEvent]) => void;
-    off: <TEvent extends keyof OverlayedAppHandlersMapping = keyof OverlayedAppHandlersMapping>(event: TEvent, cb: OverlayedAppHandlersMapping[TEvent]) => void;
+	on: <TEvent extends keyof OverlayedAppHandlersMapping = keyof OverlayedAppHandlersMapping>(
+		event: TEvent,
+		cb: OverlayedAppHandlersMapping[TEvent],
+	) => void;
+	off: <TEvent extends keyof OverlayedAppHandlersMapping = keyof OverlayedAppHandlersMapping>(
+		event: TEvent,
+		cb: OverlayedAppHandlersMapping[TEvent],
+	) => void;
 };
 
 declare type OverlayedAppHandlersMapping = {
-    error: (data: ErrorManagerEvents["error"]) => void;
-    warning: (data: ErrorManagerEvents["warning"]) => void;
-    fatal: (data: ErrorManagerEvents["fatal"]) => void;
-    gameLaunch: GameLaunchManagerEvents["gameLaunch"];
-    gameClose: GameLaunchManagerEvents["gameClose"];
-    gameReady: GameLaunchManagerEvents["gameReady"];
+	error: (data: ErrorManagerEvents["error"]) => void;
+	warning: (data: ErrorManagerEvents["warning"]) => void;
+	fatal: (data: ErrorManagerEvents["fatal"]) => void;
+	gameLaunch: GameLaunchManagerEvents["gameLaunch"];
+	gameClose: GameLaunchManagerEvents["gameClose"];
+	gameReady: GameLaunchManagerEvents["gameReady"];
 };
 
 declare interface OverlayedAppInputModule {
-    scope: (scopeName: string) => ReturnType<OverridesManager["scope"]>;
-    raw: OverlayedAppInputModuleRaw;
+	scope: (scopeName: string) => ReturnType<OverridesManager["scope"]>;
+	raw: OverlayedAppInputModuleRaw;
 }
 
 declare type OverlayedAppInputModuleRaw = {
-    /**
-     * Block the game from receiving mouse input.
-     *
-     * @param block Whether to block mouse input.
-     */
-    setGlobalMouseBlock(block: boolean): void;
-    /**
-     * Block the game from receiving keyboard input.
-     *
-     * @param block Whether to block keyboard input.
-     */
-    setGlobalKeyboardBlock(block: boolean): void;
-    /**
-     * Show or hide the cursor.
-     *
-     * @param show Whether to show or hide the cursor.
-     */
-    setGlobalCursorOverride(show: boolean): void;
-    /**
-     * Block the game from receiving input for a specific key.
-     *
-     * @param key The key to block input for.
-     * @param block Whether to block input for the key.
-     */
-    setKeyInputBlock(key: VirtualKey, block: boolean): void;
-    /**
-     * Get the current state of the global mouse block.
-     */
-    getGlobalMouseBlock(): boolean;
-    /**
-     * Get the current state of the global keyboard block.
-     */
-    getGlobalKeyboardBlock(): boolean;
-    /**
-     * Get the current state of the global cursor override.
-     */
-    getGlobalCursorOverride(): boolean;
-    /**
-     * Get the current state of the key input block for a specific key.
-     * @param key The key to block input for.
-     */
-    getKeyInputBlock(key: VirtualKey): boolean;
+	/**
+	 * Block the game from receiving mouse input.
+	 *
+	 * @param block Whether to block mouse input.
+	 */
+	setGlobalMouseBlock(block: boolean): void;
+	/**
+	 * Block the game from receiving keyboard input.
+	 *
+	 * @param block Whether to block keyboard input.
+	 */
+	setGlobalKeyboardBlock(block: boolean): void;
+	/**
+	 * Show or hide the cursor.
+	 *
+	 * @param show Whether to show or hide the cursor.
+	 */
+	setGlobalCursorOverride(show: boolean): void;
+	/**
+	 * Block the game from receiving input for a specific key.
+	 *
+	 * @param key The key to block input for.
+	 * @param block Whether to block input for the key.
+	 */
+	setKeyInputBlock(key: VirtualKey, block: boolean): void;
+	/**
+	 * Get the current state of the global mouse block.
+	 */
+	getGlobalMouseBlock(): boolean;
+	/**
+	 * Get the current state of the global keyboard block.
+	 */
+	getGlobalKeyboardBlock(): boolean;
+	/**
+	 * Get the current state of the global cursor override.
+	 */
+	getGlobalCursorOverride(): boolean;
+	/**
+	 * Get the current state of the key input block for a specific key.
+	 * @param key The key to block input for.
+	 */
+	getKeyInputBlock(key: VirtualKey): boolean;
 };
 
-declare type OverlayedAppKeybindModule<TKeybind extends string> = Record<TKeybind, {
-    on: <TEvent extends "down" | "up" | "toggle">(event: TEvent, cb: KeybindCallbacks[TEvent]) => void;
-}> & {
-    /**
-     * Get the current user keybinds.
-     */
-    getConfig: () => OverlayedAppKeybindsConfig<TKeybind>;
-    /**
-     * Pause keybind listening. Essential for pausing keybind listening when recording new keybinds.
-     */
-    pauseKeybindListening: () => void;
-    /**
-     * Resume keybind listening. Essential for resuming keybind listening after recording new keybinds.
-     */
-    resumeKeybindListening: () => void;
-    /**
-     * Update a single keybind.
-     *
-     * @param keybind The keybind to update.
-     * @param keybindConfig The new keybind config.
-     */
-    updateKeybind: (keybind: TKeybind, keybindConfig: OverlayedAppKeybindsConfig<TKeybind>[TKeybind]) => void;
-    /**
-     * Bulk update keybinds.
-     *
-     * @param keybinds The keybinds to update. Keybind keys not provided will not be updated.
-     */
-    updateKeybinds: (keybinds: Partial<OverlayedAppKeybindsConfig<TKeybind>>) => void;
+declare type OverlayedAppKeybindModule<TKeybind extends string> = Record<
+	TKeybind,
+	{
+		on: <TEvent extends "down" | "up" | "toggle">(event: TEvent, cb: KeybindCallbacks[TEvent]) => void;
+	}
+> & {
+	/**
+	 * Get the current user keybinds.
+	 */
+	getConfig: () => OverlayedAppKeybindsConfig<TKeybind>;
+	/**
+	 * Pause keybind listening. Essential for pausing keybind listening when recording new keybinds.
+	 */
+	pauseKeybindListening: () => void;
+	/**
+	 * Resume keybind listening. Essential for resuming keybind listening after recording new keybinds.
+	 */
+	resumeKeybindListening: () => void;
+	/**
+	 * Update a single keybind.
+	 *
+	 * @param keybind The keybind to update.
+	 * @param keybindConfig The new keybind config.
+	 */
+	updateKeybind: (keybind: TKeybind, keybindConfig: OverlayedAppKeybindsConfig<TKeybind>[TKeybind]) => void;
+	/**
+	 * Bulk update keybinds.
+	 *
+	 * @param keybinds The keybinds to update. Keybind keys not provided will not be updated.
+	 */
+	updateKeybinds: (keybinds: Partial<OverlayedAppKeybindsConfig<TKeybind>>) => void;
 };
 
-declare type OverlayedAppKeybindsConfig<TKeybind extends string> = Record<TKeybind, {
-    /**
-     * - An array of [KeyboardEvent#code](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)
-     * - Whatever you configure will be the default value
-     * - [Here](https://www.toptal.com/developers/keycode) is a good tool to easily find the codes for a given hotkey
-     */
-    keys: OverlayedAppKeybindsConfigKey[];
-    /**
-     * - `toggle` will trigger the callback when the key is toggled on and off
-     * - `hold` will trigger the callback when the key is held down
-     * - This can be updated at runtime
-     */
-    mode: OverlayedAppKeybindsConfigMode;
-}>;
-
-declare type OverlayedAppKeybindsConfigKey = "ControlLeft" | "AltLeft" | "ShiftLeft" | "AltRight" | "ControlRight" | "ShiftRight" | (string & {});
+declare type OverlayedAppKeybindsConfig<TKeybind extends string> = Record<
+	TKeybind,
+	{
+		/**
+		 * - An array of [KeyboardEvent#code](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/code)
+		 * - Whatever you configure will be the default value
+		 * - [Here](https://www.toptal.com/developers/keycode) is a good tool to easily find the codes for a given hotkey
+		 */
+		keys: OverlayedAppKeybindsConfigKey[];
+		/**
+		 * - `toggle` will trigger the callback when the key is toggled on and off
+		 * - `hold` will trigger the callback when the key is held down
+		 * - This can be updated at runtime
+		 */
+		mode: OverlayedAppKeybindsConfigMode;
+	}
+>;
+
+declare type OverlayedAppKeybindsConfigKey =
+	| "ControlLeft"
+	| "AltLeft"
+	| "ShiftLeft"
+	| "AltRight"
+	| "ControlRight"
+	| "ShiftRight"
+	| (string & {});
 
 declare type OverlayedAppKeybindsConfigMode = "toggle" | "hold";
 
-declare interface OverlayedAppWindowsModule extends Pick<RenderInterface, "on" | "off" | "once" | "addListener" | "prependListener" | "prependOnceListener" | "removeListener" | "removeAllListeners"> {
-    createWindow(options: RenderWindowConstructorOptions): RenderWindow;
-    getActiveGameInfo: () => ActiveGameInfo;
+declare interface OverlayedAppWindowsModule
+	extends Pick<
+		RenderInterface,
+		| "on"
+		| "off"
+		| "once"
+		| "addListener"
+		| "prependListener"
+		| "prependOnceListener"
+		| "removeListener"
+		| "removeAllListeners"
+	> {
+	createWindow(options: RenderWindowConstructorOptions): RenderWindow;
+	getActiveGameInfo: () => ActiveGameInfo;
 }
 
 declare interface OverlayedOptions<TModule extends GameModule, TKeybind extends string> {
-    /**
-     * The electron instance.
-     *
-     * Must be imported globally like:
-     * ```ts
-     * import { electron } from "electron";
-     * ```
-     * or
-     * ```ts
-     * const electron = require("electron");
-     * ```
-     */
-    electron: electron;
-    /**
-     * The application id, this can be found in the [Overlayed Dashboard](https://dashboard.overlayed.gg/settings/applications).
-     */
-    applicationId: string;
-    /**
-     * App modules to load.
-     */
-    modules: TModule[];
-    /**
-     * App keybinds config.
-     */
-    keybinds: OverlayedAppKeybindsConfig<TKeybind>;
-    /**
-     * Whether to initialize the app when the module is loaded.
-     * @default true;
-     */
-    init?: boolean;
-    /**
-     * When true, the overlay will be loaded for all supported games.
-     * When false, only games registered under the `modules` array will be loaded.
-     *
-     * @default false
-     */
-    universal?: boolean;
-    /**
-     * @deprecated
-     */
-    channel?: string;
+	/**
+	 * The electron instance.
+	 *
+	 * Must be imported globally like:
+	 * ```ts
+	 * import { electron } from "electron";
+	 * ```
+	 * or
+	 * ```ts
+	 * const electron = require("electron");
+	 * ```
+	 */
+	electron: electron;
+	/**
+	 * The application id, this can be found in the [Overlayed Dashboard](https://dashboard.overlayed.gg/settings/applications).
+	 */
+	applicationId: string;
+	/**
+	 * App modules to load.
+	 */
+	modules: TModule[];
+	/**
+	 * App keybinds config.
+	 */
+	keybinds: OverlayedAppKeybindsConfig<TKeybind>;
+	/**
+	 * Whether to initialize the app when the module is loaded.
+	 * @default true;
+	 */
+	init?: boolean;
+	/**
+	 * When true, the overlay will be loaded for all supported games.
+	 * When false, only games registered under the `modules` array will be loaded.
+	 *
+	 * @default false
+	 */
+	universal?: boolean;
+	/**
+	 * @deprecated
+	 */
+	channel?: string;
 }
 
 declare class OverridesManager extends Manager {
-    private renderInterface;
-    private globalCursorOverrideCount;
-    private globalMouseBlockCount;
-    private globalKeyboardBlockCount;
-    private keyInputBlocks;
-    constructor(interfaceName: RenderInterfaceName);
-    scope(scopeName: string): OverridesManagerScope;
-    private setGlobalCursorOverride;
-    private setGlobalMouseBlock;
-    private setGlobalKeyboardBlock;
-    private setKeyInputBlock;
+	private renderInterface;
+	private globalCursorOverrideCount;
+	private globalMouseBlockCount;
+	private globalKeyboardBlockCount;
+	private keyInputBlocks;
+	constructor(interfaceName: RenderInterfaceName);
+	scope(scopeName: string): OverridesManagerScope;
+	private setGlobalCursorOverride;
+	private setGlobalMouseBlock;
+	private setGlobalKeyboardBlock;
+	private setKeyInputBlock;
 }
 
 export declare interface OverridesManagerScope {
-    setGlobalCursorOverride: (override: boolean) => void;
-    setGlobalMouseBlock: (block: boolean) => void;
-    setGlobalKeyboardBlock: (block: boolean) => void;
-    setKeyInputBlock: (key: number, block: boolean) => void;
+	setGlobalCursorOverride: (override: boolean) => void;
+	setGlobalMouseBlock: (block: boolean) => void;
+	setGlobalKeyboardBlock: (block: boolean) => void;
+	setKeyInputBlock: (key: number, block: boolean) => void;
 }
 
 export class RenderInterface {
-    		constructor(name: String, options?: { maxWindowCount?: number; eventQueueSize?: number; access?: AccessLevel }); // default: { maxWindowCount: 10, eventQueueSize: 200, access: AccessLevel.Default }
-
-    		newWindowInternal(browserWindow: Electron.BrowserWindow, options?: RenderWindowConstructorOptions): RenderWindow;
-
-    		getGlobalMouseBlock(): boolean;
-    		getGlobalKeyboardBlock(): boolean;
-    		getGlobalCursorOverride(): boolean;
-    		getKeyInputBlock(key: VirtualKey): boolean;
-
-    		setGlobalMouseBlock(block: boolean): void;
-    		setGlobalKeyboardBlock(block: boolean): void;
-    		setGlobalCursorOverride(show: boolean): void;
-    		setKeyInputBlock(key: VirtualKey, block: boolean): void;
-
-    		eventNames(): string[];
-    		getMaxListeners(): number;
-    		removeAllListeners(): this;
-
-    		listeners(eventName: "keyDown"): Function[];
-    		rawListeners(eventName: "keyDown"): Function[];
-    		listenerCount(eventName: "keyDown", listener?: (event: KeyboardKeyEvent) => void): number;
-
-    		on(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
-    		once(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
-    		addListener(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
-    		prependListener(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
-    		prependOnceListener(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
-
-    		off(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
-    		removeListener(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
-    		removeAllListeners(eventName: "keyDown"): this;
-
-    		listeners(eventName: "keyUp"): Function[];
-    		rawListeners(eventName: "keyUp"): Function[];
-    		listenerCount(eventName: "keyUp", listener?: (event: KeyboardKeyEvent) => void): number;
-
-    		on(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
-    		once(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
-    		addListener(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
-    		prependListener(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
-    		prependOnceListener(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
-
-    		off(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
-    		removeListener(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
-    		removeAllListeners(eventName: "keyUp"): this;
-
-    		listeners(eventName: "mouseDown"): Function[];
-    		rawListeners(eventName: "mouseDown"): Function[];
-    		listenerCount(eventName: "mouseDown", listener?: (event: MouseButtonEvent) => void): number;
-
-    		on(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
-    		once(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
-    		addListener(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
-    		prependListener(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
-    		prependOnceListener(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
-
-    		off(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
-    		removeListener(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
-    		removeAllListeners(eventName: "mouseDown"): this;
-
-    		listeners(eventName: "mouseUp"): Function[];
-    		rawListeners(eventName: "mouseUp"): Function[];
-    		listenerCount(eventName: "mouseUp", listener?: (event: MouseButtonEvent) => void): number;
-
-    		on(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
-    		once(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
-    		addListener(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
-    		prependListener(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
-    		prependOnceListener(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
-
-    		off(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
-    		removeListener(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
-    		removeAllListeners(eventName: "mouseUp"): this;
-
-    		listeners(eventName: "resolution"): Function[];
-    		rawListeners(eventName: "resolution"): Function[];
-    		listenerCount(eventName: "resolution", listener?: (width: number, height: number) => void): number;
-
-    		on(eventName: "resolution", listener: (width: number, height: number) => void): this;
-    		once(eventName: "resolution", listener: (width: number, height: number) => void): this;
-    		addListener(eventName: "resolution", listener: (width: number, height: number) => void): this;
-    		prependListener(eventName: "resolution", listener: (width: number, height: number) => void): this;
-    		prependOnceListener(eventName: "resolution", listener: (width: number, height: number) => void): this;
-
-    		off(eventName: "resolution", listener: (width: number, height: number) => void): this;
-    		removeListener(eventName: "resolution", listener: (width: number, height: number) => void): this;
-    		removeAllListeners(eventName: "resolution"): this;
-
-    		listeners(eventName: "keyboardFocus"): Function[];
-    		rawListeners(eventName: "keyboardFocus"): Function[];
-    		listenerCount(eventName: "keyboardFocus", listener?: (focus: boolean) => void): number;
-
-    		on(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
-    		once(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
-    		addListener(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
-    		prependListener(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
-    		prependOnceListener(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
-
-    		off(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
-    		removeListener(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
-    		removeAllListeners(eventName: "keyboardFocus"): this;
-    	}
+	constructor(name: String, options?: { maxWindowCount?: number; eventQueueSize?: number; access?: AccessLevel }); // default: { maxWindowCount: 10, eventQueueSize: 200, access: AccessLevel.Default }
+
+	newWindowInternal(browserWindow: Electron.BrowserWindow, options?: RenderWindowConstructorOptions): RenderWindow;
+
+	getGlobalMouseBlock(): boolean;
+	getGlobalKeyboardBlock(): boolean;
+	getGlobalCursorOverride(): boolean;
+	getKeyInputBlock(key: VirtualKey): boolean;
+
+	setGlobalMouseBlock(block: boolean): void;
+	setGlobalKeyboardBlock(block: boolean): void;
+	setGlobalCursorOverride(show: boolean): void;
+	setKeyInputBlock(key: VirtualKey, block: boolean): void;
+
+	eventNames(): string[];
+	getMaxListeners(): number;
+	removeAllListeners(): this;
+
+	listeners(eventName: "keyDown"): Function[];
+	rawListeners(eventName: "keyDown"): Function[];
+	listenerCount(eventName: "keyDown", listener?: (event: KeyboardKeyEvent) => void): number;
+
+	on(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
+	once(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
+	addListener(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
+	prependListener(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
+	prependOnceListener(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
+
+	off(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
+	removeListener(eventName: "keyDown", listener: (event: KeyboardKeyEvent) => void): this;
+	removeAllListeners(eventName: "keyDown"): this;
+
+	listeners(eventName: "keyUp"): Function[];
+	rawListeners(eventName: "keyUp"): Function[];
+	listenerCount(eventName: "keyUp", listener?: (event: KeyboardKeyEvent) => void): number;
+
+	on(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
+	once(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
+	addListener(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
+	prependListener(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
+	prependOnceListener(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
+
+	off(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
+	removeListener(eventName: "keyUp", listener: (event: KeyboardKeyEvent) => void): this;
+	removeAllListeners(eventName: "keyUp"): this;
+
+	listeners(eventName: "mouseDown"): Function[];
+	rawListeners(eventName: "mouseDown"): Function[];
+	listenerCount(eventName: "mouseDown", listener?: (event: MouseButtonEvent) => void): number;
+
+	on(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
+	once(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
+	addListener(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
+	prependListener(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
+	prependOnceListener(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
+
+	off(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
+	removeListener(eventName: "mouseDown", listener: (event: MouseButtonEvent) => void): this;
+	removeAllListeners(eventName: "mouseDown"): this;
+
+	listeners(eventName: "mouseUp"): Function[];
+	rawListeners(eventName: "mouseUp"): Function[];
+	listenerCount(eventName: "mouseUp", listener?: (event: MouseButtonEvent) => void): number;
+
+	on(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
+	once(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
+	addListener(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
+	prependListener(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
+	prependOnceListener(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
+
+	off(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
+	removeListener(eventName: "mouseUp", listener: (event: MouseButtonEvent) => void): this;
+	removeAllListeners(eventName: "mouseUp"): this;
+
+	listeners(eventName: "resolution"): Function[];
+	rawListeners(eventName: "resolution"): Function[];
+	listenerCount(eventName: "resolution", listener?: (width: number, height: number) => void): number;
+
+	on(eventName: "resolution", listener: (width: number, height: number) => void): this;
+	once(eventName: "resolution", listener: (width: number, height: number) => void): this;
+	addListener(eventName: "resolution", listener: (width: number, height: number) => void): this;
+	prependListener(eventName: "resolution", listener: (width: number, height: number) => void): this;
+	prependOnceListener(eventName: "resolution", listener: (width: number, height: number) => void): this;
+
+	off(eventName: "resolution", listener: (width: number, height: number) => void): this;
+	removeListener(eventName: "resolution", listener: (width: number, height: number) => void): this;
+	removeAllListeners(eventName: "resolution"): this;
+
+	listeners(eventName: "keyboardFocus"): Function[];
+	rawListeners(eventName: "keyboardFocus"): Function[];
+	listenerCount(eventName: "keyboardFocus", listener?: (focus: boolean) => void): number;
+
+	on(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
+	once(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
+	addListener(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
+	prependListener(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
+	prependOnceListener(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
+
+	off(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
+	removeListener(eventName: "keyboardFocus", listener: (focus: boolean) => void): this;
+	removeAllListeners(eventName: "keyboardFocus"): this;
+}
 
 declare type RenderInterfaceName = "OGG_SIEGE";
 
 export interface RenderWindow extends Electron.BrowserWindow {
-    		getLayer(): number;
-    		getInput(): boolean;
-    		getInputBlock(): boolean;
-    		getCursorOverride(): boolean;
-
-    		setLayer(layer: number): void;
-    		setInput(input: boolean): void;
-    		setInputBlock(block: boolean): void;
-    		setCursorOverride(override: boolean): void;
-    	}
+	getLayer(): number;
+	getInput(): boolean;
+	getInputBlock(): boolean;
+	getCursorOverride(): boolean;
+
+	setLayer(layer: number): void;
+	setInput(input: boolean): void;
+	setInputBlock(block: boolean): void;
+	setCursorOverride(override: boolean): void;
+}
 
 export interface RenderWindowConstructorOptions extends Electron.BrowserWindowConstructorOptions {
-    		layer?: number; // default: 0
+	layer?: number; // default: 0
 
-    		createForeground?: boolean; // default: true
+	createForeground?: boolean; // default: true
 
-    		hasInput?: boolean; // default: true
-    		hasInputBlock?: boolean; // default: true
-    		hasCursorOverride?: boolean; // default: true
-    	}
+	hasInput?: boolean; // default: true
+	hasInputBlock?: boolean; // default: true
+	hasCursorOverride?: boolean; // default: true
+}
 
 export declare function setFetchLatestTokenCallback(newFetchLatestToken: () => Promise<unknown> | undefined): void;
 
 export declare function setUpdaterTokenResolver(newTokenResolver: () => string | undefined): void;
 
 export const enum VirtualKey {
-    		LeftButton = 0x01,
-    		RightButton = 0x02,
-    		Cancel = 0x03,
-    		MiddleButton = 0x04,
-    		ExtraButton1 = 0x05,
-    		ExtraButton2 = 0x06,
-    		Back = 0x08,
-    		Tab = 0x09,
-    		Clear = 0x0c,
-    		Return = 0x0d,
-    		Shift = 0x10,
-    		Control = 0x11,
-    		Menu = 0x12,
-    		Pause = 0x13,
-    		CapsLock = 0x14,
-    		Kana = 0x15,
-    		Hangeul = 0x15,
-    		Hangul = 0x15,
-    		Junja = 0x17,
-    		Final = 0x18,
-    		Hanja = 0x19,
-    		Kanji = 0x19,
-    		Escape = 0x1b,
-    		Convert = 0x1c,
-    		NonConvert = 0x1d,
-    		Accept = 0x1e,
-    		ModeChange = 0x1f,
-    		Space = 0x20,
-    		Prior = 0x21,
-    		Next = 0x22,
-    		End = 0x23,
-    		Home = 0x24,
-    		Left = 0x25,
-    		Up = 0x26,
-    		Right = 0x27,
-    		Down = 0x28,
-    		Select = 0x29,
-    		Print = 0x2a,
-    		Execute = 0x2b,
-    		Snapshot = 0x2c,
-    		Insert = 0x2d,
-    		Delete = 0x2e,
-    		Help = 0x2f,
-    		N0 = 0x30,
-    		N1 = 0x31,
-    		N2 = 0x32,
-    		N3 = 0x33,
-    		N4 = 0x34,
-    		N5 = 0x35,
-    		N6 = 0x36,
-    		N7 = 0x37,
-    		N8 = 0x38,
-    		N9 = 0x39,
-    		A = 0x41,
-    		B = 0x42,
-    		C = 0x43,
-    		D = 0x44,
-    		E = 0x45,
-    		F = 0x46,
-    		G = 0x47,
-    		H = 0x48,
-    		I = 0x49,
-    		J = 0x4a,
-    		K = 0x4b,
-    		L = 0x4c,
-    		M = 0x4d,
-    		N = 0x4e,
-    		O = 0x4f,
-    		P = 0x50,
-    		Q = 0x51,
-    		R = 0x52,
-    		S = 0x53,
-    		T = 0x54,
-    		U = 0x55,
-    		V = 0x56,
-    		W = 0x57,
-    		X = 0x58,
-    		Y = 0x59,
-    		Z = 0x5a,
-    		LeftWindows = 0x5b,
-    		RightWindows = 0x5c,
-    		Application = 0x5d,
-    		Sleep = 0x5f,
-    		Numpad0 = 0x60,
-    		Numpad1 = 0x61,
-    		Numpad2 = 0x62,
-    		Numpad3 = 0x63,
-    		Numpad4 = 0x64,
-    		Numpad5 = 0x65,
-    		Numpad6 = 0x66,
-    		Numpad7 = 0x67,
-    		Numpad8 = 0x68,
-    		Numpad9 = 0x69,
-    		Multiply = 0x6a,
-    		Add = 0x6b,
-    		Separator = 0x6c,
-    		Subtract = 0x6d,
-    		Decimal = 0x6e,
-    		Divide = 0x6f,
-    		F1 = 0x70,
-    		F2 = 0x71,
-    		F3 = 0x72,
-    		F4 = 0x73,
-    		F5 = 0x74,
-    		F6 = 0x75,
-    		F7 = 0x76,
-    		F8 = 0x77,
-    		F9 = 0x78,
-    		F10 = 0x79,
-    		F11 = 0x7a,
-    		F12 = 0x7b,
-    		F13 = 0x7c,
-    		F14 = 0x7d,
-    		F15 = 0x7e,
-    		F16 = 0x7f,
-    		F17 = 0x80,
-    		F18 = 0x81,
-    		F19 = 0x82,
-    		F20 = 0x83,
-    		F21 = 0x84,
-    		F22 = 0x85,
-    		F23 = 0x86,
-    		F24 = 0x87,
-    		NumLock = 0x90,
-    		ScrollLock = 0x91,
-    		NEC_Equal = 0x92,
-    		Fujitsu_Jisho = 0x92,
-    		Fujitsu_Masshou = 0x93,
-    		Fujitsu_Touroku = 0x94,
-    		Fujitsu_Loya = 0x95,
-    		Fujitsu_Roya = 0x96,
-    		LeftShift = 0xa0,
-    		RightShift = 0xa1,
-    		LeftControl = 0xa2,
-    		RightControl = 0xa3,
-    		LeftMenu = 0xa4,
-    		RightMenu = 0xa5,
-    		BrowserBack = 0xa6,
-    		BrowserForward = 0xa7,
-    		BrowserRefresh = 0xa8,
-    		BrowserStop = 0xa9,
-    		BrowserSearch = 0xaa,
-    		BrowserFavorites = 0xab,
-    		BrowserHome = 0xac,
-    		VolumeMute = 0xad,
-    		VolumeDown = 0xae,
-    		VolumeUp = 0xaf,
-    		MediaNextTrack = 0xb0,
-    		MediaPrevTrack = 0xb1,
-    		MediaStop = 0xb2,
-    		MediaPlayPause = 0xb3,
-    		LaunchMail = 0xb4,
-    		LaunchMediaSelect = 0xb5,
-    		LaunchApplication1 = 0xb6,
-    		LaunchApplication2 = 0xb7,
-    		OEM1 = 0xba,
-    		OEMPlus = 0xbb,
-    		OEMComma = 0xbc,
-    		OEMMinus = 0xbd,
-    		OEMPeriod = 0xbe,
-    		OEM2 = 0xbf,
-    		OEM3 = 0xc0,
-    		OEM4 = 0xdb,
-    		OEM5 = 0xdc,
-    		OEM6 = 0xdd,
-    		OEM7 = 0xde,
-    		OEM8 = 0xdf,
-    		OEMAX = 0xe1,
-    		OEM102 = 0xe2,
-    		ICOHelp = 0xe3,
-    		ICO00 = 0xe4,
-    		ProcessKey = 0xe5,
-    		ICOClear = 0xe6,
-    		Packet = 0xe7,
-    		OEMReset = 0xe9,
-    		OEMJump = 0xea,
-    		OEMPA1 = 0xeb,
-    		OEMPA2 = 0xec,
-    		OEMPA3 = 0xed,
-    		OEMWSCtrl = 0xee,
-    		OEMCUSel = 0xef,
-    		OEMATTN = 0xf0,
-    		OEMFinish = 0xf1,
-    		OEMCopy = 0xf2,
-    		OEMAuto = 0xf3,
-    		OEMENLW = 0xf4,
-    		OEMBackTab = 0xf5,
-    		ATTN = 0xf6,
-    		CRSel = 0xf7,
-    		EXSel = 0xf8,
-    		EREOF = 0xf9,
-    		Play = 0xfa,
-    		Zoom = 0xfb,
-    		Noname = 0xfc,
-    		PA1 = 0xfd,
-    		OEMClear = 0xfe,
-    	}
+	LeftButton = 0x01,
+	RightButton = 0x02,
+	Cancel = 0x03,
+	MiddleButton = 0x04,
+	ExtraButton1 = 0x05,
+	ExtraButton2 = 0x06,
+	Back = 0x08,
+	Tab = 0x09,
+	Clear = 0x0c,
+	Return = 0x0d,
+	Shift = 0x10,
+	Control = 0x11,
+	Menu = 0x12,
+	Pause = 0x13,
+	CapsLock = 0x14,
+	Kana = 0x15,
+	Hangeul = 0x15,
+	Hangul = 0x15,
+	Junja = 0x17,
+	Final = 0x18,
+	Hanja = 0x19,
+	Kanji = 0x19,
+	Escape = 0x1b,
+	Convert = 0x1c,
+	NonConvert = 0x1d,
+	Accept = 0x1e,
+	ModeChange = 0x1f,
+	Space = 0x20,
+	Prior = 0x21,
+	Next = 0x22,
+	End = 0x23,
+	Home = 0x24,
+	Left = 0x25,
+	Up = 0x26,
+	Right = 0x27,
+	Down = 0x28,
+	Select = 0x29,
+	Print = 0x2a,
+	Execute = 0x2b,
+	Snapshot = 0x2c,
+	Insert = 0x2d,
+	Delete = 0x2e,
+	Help = 0x2f,
+	N0 = 0x30,
+	N1 = 0x31,
+	N2 = 0x32,
+	N3 = 0x33,
+	N4 = 0x34,
+	N5 = 0x35,
+	N6 = 0x36,
+	N7 = 0x37,
+	N8 = 0x38,
+	N9 = 0x39,
+	A = 0x41,
+	B = 0x42,
+	C = 0x43,
+	D = 0x44,
+	E = 0x45,
+	F = 0x46,
+	G = 0x47,
+	H = 0x48,
+	I = 0x49,
+	J = 0x4a,
+	K = 0x4b,
+	L = 0x4c,
+	M = 0x4d,
+	N = 0x4e,
+	O = 0x4f,
+	P = 0x50,
+	Q = 0x51,
+	R = 0x52,
+	S = 0x53,
+	T = 0x54,
+	U = 0x55,
+	V = 0x56,
+	W = 0x57,
+	X = 0x58,
+	Y = 0x59,
+	Z = 0x5a,
+	LeftWindows = 0x5b,
+	RightWindows = 0x5c,
+	Application = 0x5d,
+	Sleep = 0x5f,
+	Numpad0 = 0x60,
+	Numpad1 = 0x61,
+	Numpad2 = 0x62,
+	Numpad3 = 0x63,
+	Numpad4 = 0x64,
+	Numpad5 = 0x65,
+	Numpad6 = 0x66,
+	Numpad7 = 0x67,
+	Numpad8 = 0x68,
+	Numpad9 = 0x69,
+	Multiply = 0x6a,
+	Add = 0x6b,
+	Separator = 0x6c,
+	Subtract = 0x6d,
+	Decimal = 0x6e,
+	Divide = 0x6f,
+	F1 = 0x70,
+	F2 = 0x71,
+	F3 = 0x72,
+	F4 = 0x73,
+	F5 = 0x74,
+	F6 = 0x75,
+	F7 = 0x76,
+	F8 = 0x77,
+	F9 = 0x78,
+	F10 = 0x79,
+	F11 = 0x7a,
+	F12 = 0x7b,
+	F13 = 0x7c,
+	F14 = 0x7d,
+	F15 = 0x7e,
+	F16 = 0x7f,
+	F17 = 0x80,
+	F18 = 0x81,
+	F19 = 0x82,
+	F20 = 0x83,
+	F21 = 0x84,
+	F22 = 0x85,
+	F23 = 0x86,
+	F24 = 0x87,
+	NumLock = 0x90,
+	ScrollLock = 0x91,
+	NEC_Equal = 0x92,
+	Fujitsu_Jisho = 0x92,
+	Fujitsu_Masshou = 0x93,
+	Fujitsu_Touroku = 0x94,
+	Fujitsu_Loya = 0x95,
+	Fujitsu_Roya = 0x96,
+	LeftShift = 0xa0,
+	RightShift = 0xa1,
+	LeftControl = 0xa2,
+	RightControl = 0xa3,
+	LeftMenu = 0xa4,
+	RightMenu = 0xa5,
+	BrowserBack = 0xa6,
+	BrowserForward = 0xa7,
+	BrowserRefresh = 0xa8,
+	BrowserStop = 0xa9,
+	BrowserSearch = 0xaa,
+	BrowserFavorites = 0xab,
+	BrowserHome = 0xac,
+	VolumeMute = 0xad,
+	VolumeDown = 0xae,
+	VolumeUp = 0xaf,
+	MediaNextTrack = 0xb0,
+	MediaPrevTrack = 0xb1,
+	MediaStop = 0xb2,
+	MediaPlayPause = 0xb3,
+	LaunchMail = 0xb4,
+	LaunchMediaSelect = 0xb5,
+	LaunchApplication1 = 0xb6,
+	LaunchApplication2 = 0xb7,
+	OEM1 = 0xba,
+	OEMPlus = 0xbb,
+	OEMComma = 0xbc,
+	OEMMinus = 0xbd,
+	OEMPeriod = 0xbe,
+	OEM2 = 0xbf,
+	OEM3 = 0xc0,
+	OEM4 = 0xdb,
+	OEM5 = 0xdc,
+	OEM6 = 0xdd,
+	OEM7 = 0xde,
+	OEM8 = 0xdf,
+	OEMAX = 0xe1,
+	OEM102 = 0xe2,
+	ICOHelp = 0xe3,
+	ICO00 = 0xe4,
+	ProcessKey = 0xe5,
+	ICOClear = 0xe6,
+	Packet = 0xe7,
+	OEMReset = 0xe9,
+	OEMJump = 0xea,
+	OEMPA1 = 0xeb,
+	OEMPA2 = 0xec,
+	OEMPA3 = 0xed,
+	OEMWSCtrl = 0xee,
+	OEMCUSel = 0xef,
+	OEMATTN = 0xf0,
+	OEMFinish = 0xf1,
+	OEMCopy = 0xf2,
+	OEMAuto = 0xf3,
+	OEMENLW = 0xf4,
+	OEMBackTab = 0xf5,
+	ATTN = 0xf6,
+	CRSel = 0xf7,
+	EXSel = 0xf8,
+	EREOF = 0xf9,
+	Play = 0xfa,
+	Zoom = 0xfb,
+	Noname = 0xfc,
+	PA1 = 0xfd,
+	OEMClear = 0xfe,
+}
 
 declare type WarningEvents = WarningInvalidEvent;
 
 declare interface WarningInvalidEvent extends ErrorManagerEvent {
-    	code: "INVALID_EVENT";
-    	data: {
-        		summary: string;
-        	};
+	code: "INVALID_EVENT";
+	data: {
+		summary: string;
+	};
 }
 
 export interface WindowEvent {
-    		window?: RenderWindow;
-    	}
-
-export { }
-
-declare global {
-	namespace Electron {
-		interface BrowserWindow {
-			isShown(): boolean;
-		}
-	}
-}
-					
+	window?: RenderWindow;
+}
+
+export {};
+
+declare global {
+	namespace Electron {
+		interface BrowserWindow {
+			isShown(): boolean;
+		}
+	}
+}