@overlayed/app 0.2.2 → 0.4.0

package/dist/index.d.ts

@@ -1,3 +1,765 @@
-export * from './overlayed';
-export { type OverlayedApp } from './types';
-//# sourceMappingURL=index.d.ts.map
+/// <reference types="electron" />
+/// <reference types="node" />
+
+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,
+    	}
+
+export declare type ActiveGameInfo = {
+    isConnected: boolean;
+    resolution: {
+        width: number;
+        height: number;
+    };
+};
+
+declare const BaseEvent: ObjectType<    {
+game: string;
+type: string;
+creation_time: number;
+}, {}>;
+
+declare type BaseEvent = typeof BaseEvent.infer;
+
+declare type CustomLoggerScope = ReturnType<typeof Logger.scope>;
+
+declare type ErrorEvents = ErrorPipeServerError | ErrorInvalidConfigFile;
+
+declare interface ErrorInvalidConfigFile extends ErrorManagerEvent {
+    	code: "INVALID_CONFIG_FILE";
+    	data: {
+        		issues: string[];
+        		filePath: string;
+        		data: unknown;
+        	};
+}
+
+declare type ErrorManagerEvent = {
+    	code: string;
+    	message: string;
+    	data: Record<string, any>;
+    	timestamp: number;
+};
+
+declare type ErrorManagerEvents = {
+    	fatal: FatalEvents;
+    	error: ErrorEvents;
+    	warning: WarningEvents;
+};
+
+declare interface ErrorPipeServerError extends ErrorManagerEvent {
+    	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 EventType<TEvent extends BaseEvent> = TEvent["type"];
+
+declare interface FatalElevationMismatch extends ErrorManagerEvent {
+    	code: "ELEVATION_MISMATCH";
+    	data: {
+        		appElevated: boolean;
+        		gameElevated: boolean;
+        	};
+}
+
+declare type FatalEvents = FatalElevationMismatch;
+
+export declare type GameLaunchManagerEvents = {
+    gameLaunchInternal: {
+        ravenGame: RavenGame;
+        process: Process;
+    };
+    gameCloseInternal: {
+        ravenGame: RavenGame;
+        process: Process;
+    };
+    gameLaunch: {
+        game: string;
+    };
+    gameClose: {
+        game: string;
+    };
+};
+
+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;
+};
+
+declare type GameModuleEventInfer<TModule extends GameModule> = TModule["events"]["event"]["infer"];
+
+declare type KeybindCallbacks = {
+    toggle?: KeybindPressedCallback;
+    down?: KeybindDownCallback;
+    up?: KeybindUpCallback;
+};
+
+export declare type KeybindConfig = (typeof KeybindSchema.infer)[string];
+
+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 type KeybindUpCallback = () => void;
+
+export interface KeyboardKeyEvent extends WindowEvent {
+    		key: VirtualKey;
+    	}
+
+declare const Logger = {
+    	scope: (name: string) => {
+        		return {
+            			log: (...args: any[]) => {
+                				console.log(name, ...args);
+                			},
+            			error: (...args: any[]) => {
+                				console.error(name, ...args);
+                			},
+            			warn: (...args: any[]) => {
+                				console.warn(name, ...args);
+                			},
+            			info: (...args: any[]) => {
+                				console.info(name, ...args);
+                			},
+            			debug: (...args: any[]) => {
+                				console.debug(name, ...args);
+                			},
+            			captureSentryException: (...args: any[]) => {
+                				console.error(name, ...args);
+                			},
+            			sentryError: (...args: any[]) => {
+                				console.error(name, ...args);
+                			},
+            			sentryLog: (...args: any[]) => {
+                				console.log(name, ...args);
+                			},
+            			sentryWarn: (...args: any[]) => {
+                				console.warn(name, ...args);
+                			},
+            		};
+        	},
+    	error: (...args: any[]) => {
+        		console.error(name, ...args);
+        	},
+    	warn: (...args: any[]) => {
+        		console.warn(name, ...args);
+        	},
+    	info: (...args: any[]) => {
+        		console.info(name, ...args);
+        	},
+    	debug: (...args: any[]) => {
+        		console.debug(name, ...args);
+        	},
+    	captureSentryException: (...args: any[]) => {
+        		console.error(name, ...args);
+        	},
+    	sentryError: (...args: any[]) => {
+        		console.error(name, ...args);
+        	},
+    	sentryLog: (...args: any[]) => {
+        		console.log(name, ...args);
+        	},
+    	sentryWarn: (...args: any[]) => {
+        		console.warn(name, ...args);
+        	},
+    	sentryInfo: (...args: any[]) => {
+        		console.info(name, ...args);
+        	},
+};
+
+/** This should be kept in sync with EventEmitterManager */
+declare class Manager {
+    protected logger: CustomLoggerScope;
+    initialized: boolean;
+    constructor(name: string);
+    init(): void;
+    destroy(): void;
+}
+
+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>(data: OverlayedData<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;
+    /**
+     * 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;
+};
+
+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;
+    };
+};
+
+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;
+};
+
+declare type OverlayedAppHandlersMapping = {
+    error: (data: ErrorManagerEvents["error"]) => void;
+    warning: (data: ErrorManagerEvents["warning"]) => void;
+    fatal: (data: ErrorManagerEvents["fatal"]) => void;
+    gameLaunch: (data: GameLaunchManagerEvents["gameLaunch"]) => void;
+    gameClose: (data: GameLaunchManagerEvents["gameClose"]) => void;
+};
+
+declare interface OverlayedAppInputModule {
+    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;
+};
+
+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: Array<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 = "ctrl" | "shift" | "alt" | (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 OverlayedData<TModule extends GameModule, TKeybind extends string> {
+    /**
+     * The app name.
+     *
+     * TODO: replace with endpoint to get app name from server.
+     */
+    appName: 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;
+}
+
+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;
+}
+
+export declare interface OverridesManagerScope {
+    setGlobalCursorOverride: (override: boolean) => void;
+    setGlobalMouseBlock: (block: boolean) => void;
+    setGlobalKeyboardBlock: (block: boolean) => void;
+    setKeyInputBlock: (key: number, block: boolean) => void;
+}
+
+declare interface RavenGame {
+    name: string;
+    identifier: RavenGameIdentifier;
+    executables: string[];
+    dlls_to_inject: string[];
+    version_pattern: string;
+}
+
+declare type RavenGameIdentifier = "siege";
+
+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;
+    	}
+
+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;
+    	}
+
+export interface RenderWindowConstructorOptions extends Electron.BrowserWindowConstructorOptions {
+    		layer?: number; // default: 0
+
+    		createForeground?: boolean; // default: true
+
+    		hasInput?: boolean; // default: true
+    		hasInputBlock?: boolean; // default: true
+    		hasCursorOverride?: boolean; // default: true
+    	}
+
+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,
+    	}
+
+declare type WarningEvents = WarningInvalidEvent;
+
+declare interface WarningInvalidEvent extends ErrorManagerEvent {
+    	code: "INVALID_EVENT";
+    	data: {
+        		summary: string;
+        	};
+}
+
+export interface WindowEvent {
+    		window?: RenderWindow;
+    	}
+
+export { }