@overlayed/app 0.12.0 → 0.13.0

package/dist/index.d.ts

@@ -1,944 +1,464 @@
-/// <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";
-
-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;
-
-/**
- * A `Brand` is a type that takes at minimum two type parameters. Given a base
- * type `Base` and some unique and arbitrary branding type `Branding`, it
- * produces a type based on but distinct from `Base`. The resulting branded
- * type is not directly assignable from the base type, and not mutually
- * assignable with another branded type derived from the same base type.
- *
- * Take care that the branding type is unique. Two branded types that share the
- * same base type and branding type are considered the same type! There are two
- * ways to avoid this.
- *
- * The first way is to supply a third type parameter, `ReservedName`, with a
- * string literal type that is not `__type__`, which is the default.
- *
- * The second way is to define a branded type in terms of its surrounding
- * interface, thereby forming a recursive type. This is possible because there
- * are no constraints on what the branding type must be. It does not have to
- * be a string literal type, even though it often is.
- *
- * @example
- * ```
- * type Path = Brand<string, 'path'>;
- * type UserId = Brand<number, 'user'>;
- * type DifferentUserId = Brand<number, 'user', '__kind__'>;
- * interface Post { id: Brand<number, Post> }
- * ```
- */
-declare type Brand<Base, Branding, ReservedName extends string = "__type__"> = Base & {
-	[K in ReservedName]: Branding;
-} & { __witness__: Base };
-
-declare interface CortexEvents 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;
-	};
-}
-
-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 = {
-	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[];
-}
-
-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 = AsSingleton(LoggerClass, "main.log");
-
-declare interface LoggerScope {
-	scope: (name: string) => LoggerScope;
-	error: (...args: any[]) => void;
-	warn: (...args: any[]) => void;
-	info: (...args: any[]) => void;
-	log: (...args: any[]) => void;
-}
-
-/** This should be kept in sync with EventEmitterManager */
-declare class Manager {
-	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;
-		log: OverlayedAppLoggingModule;
-		/**
-		 * 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;
-}
-
-declare interface OverlayedAppCortexModule {
-	track: <TEventName extends keyof CortexEvents>(name: TEventName, data: CortexEvents[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;
-	};
-};
-
-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: GameLaunchManagerEvents["gameLaunch"];
-	gameClose: GameLaunchManagerEvents["gameClose"];
-	gameReady: GameLaunchManagerEvents["gameReady"];
-};
-
-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: 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 OverlayedAppLoggingModule {
-	/**
-	 * Returns a scoped logging instance. Each message will be prefixed with the scope name.
-	 *
-	 * ```ts
-	 * const scope = overlayed.log.scope("MyScope");
-	 * scope.info("Hello, world!");
-	 * // [2025-07-20 01:51:40.969] [log] [MyScope] Hello, world!
-	 * ```
-	 *
-	 * @param scopeName - The name of the scope.
-	 * @returns The logger scope.
-	 */
-	scope: (scopeName: string) => LoggerScope;
-	info: (message: string) => void;
-	warn: (message: string) => void;
-	error: (message: string) => void;
-	/**
-	 * Submits info you provide, app logs, overlayed logs, and any additional files you provide to be viewed
-	 * in your Overlayed dashboard.
-	 *
-	 * @param info - The information to include in the bug report.
-	 * @param options - The options to include in the bug report.
-	 * @returns The bug report id.
-	 */
-	submitBugReport: (
-		info: OverlayedAppLoggingModuleInfo,
-		options?: OverlayedAppLoggingModuleSubmitBugReportOptions,
-	) => Promise<
-		Result<
-			true,
-			{
-				message: string;
-				error: unknown;
-			}
-		>
-	>;
-}
-
-declare interface OverlayedAppLoggingModuleInfo extends Record<string, string | undefined> {
-	email?: string;
-	username?: string;
-	message?: string;
-	category?: string;
-	version?: string;
-}
-
-declare interface OverlayedAppLoggingModuleSubmitBugReportOptions {
-	/**
-	 * A key value record of additional files to include in the bug report.
-	 *
-	 * The key is the name of the file, and the value is the content of the file.
-	 */
-	additionalFiles?: Record<string, string>;
-}
-
-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 version of the app.
-	 *
-	 * @deprecated
-	 */
-	version?: 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;
-}
-
-export declare interface OverridesManagerScope {
-	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;
-}
-
-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
-}
-
-declare type Result<T, E = string> = [T, undefined] | [undefined, E];
-
-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,
-}
-
-declare type WarningEvents = WarningInvalidEvent;
-
-declare interface WarningInvalidEvent extends ErrorManagerEvent {
-	code: "INVALID_EVENT";
-	data: {
-		summary: string;
-	};
-}
-
-export interface WindowEvent {
-	window?: RenderWindow;
-}
-
-export {};
-
-declare global {
-	namespace Electron {
-		interface BrowserWindow {
-			isShown(): boolean;
-		}
-	}
-}
+import * as electron0 from "electron";
+import { BrowserWindow } from "electron";
+import { EventCallback, EventType, GameModule, GameModuleEventInfer } from "@overlayed/events";
+import * as arktype_internal_attributes_ts0 from "arktype/internal/attributes.ts";
+import * as arktype_internal_methods_object_ts0 from "arktype/internal/methods/object.ts";
+import { CustomLoggerScope, ErrorManagerEvents } from "@overlayed/utils-node";
+import { GameModel, setUpdaterTokenResolver } from "@overlayed/api";
+import { Process } from "@overlayed-gg/native-interface";
+import { MaybePromise } from "@overlayed/utils";
+import {
+	AccessLevel,
+	KeyboardKeyEvent,
+	MouseButtonEvent,
+	RenderInterface,
+	RenderInterface as RenderInterface$1,
+	RenderWindow,
+	RenderWindow as RenderWindow$1,
+	RenderWindowConstructorOptions,
+	RenderWindowConstructorOptions as RenderWindowConstructorOptions$1,
+	VirtualKey,
+	WindowEvent,
+} from "@overlayed-gg/render-interface";
+import { RenderInterfaceName } from "@overlayed/native-managers";
+
+//#region src/managers/manager.d.ts
+/** This should be kept in sync with EventEmitterManager */
+declare class Manager {
+	protected logger: CustomLoggerScope;
+	initialized: boolean;
+	constructor(name: string);
+	init(): void;
+	destroy(): void;
+}
+/** This should be kept in sync with Manager */
+//#endregion
+//#region src/managers/keybindManager.d.ts
+type KeybindPressedCallback = () => string | void;
+type KeybindDownCallback = () => string | void;
+type KeybindUpCallback = () => void;
+type KeybindCallbacks = {
+	toggle?: KeybindPressedCallback;
+	down?: KeybindDownCallback;
+	up?: KeybindUpCallback;
+};
+declare const KeybindSchema: arktype_internal_methods_object_ts0.ObjectType<
+	{
+		[x: string]: {
+			keys: string[];
+			mode: (In: "toggle" | "hold") => arktype_internal_attributes_ts0.Out<"toggle" | "hold">;
+		};
+	},
+	{}
+>;
+type KeybindSchemaEntry = (typeof KeybindSchema.infer)[string];
+//#endregion
+//#region src/managers/gameLaunchManager.d.ts
+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>;
+};
+//#endregion
+//#region src/utilities/publicTypes.d.ts
+type ActiveGameInfo = {
+	isConnected: boolean;
+	resolution: {
+		width: number;
+		height: number;
+	};
+};
+interface OverridesManagerScope {
+	setGlobalCursorOverride: (override: boolean) => void;
+	setGlobalMouseBlock: (block: boolean) => void;
+	setGlobalKeyboardBlock: (block: boolean) => void;
+	setKeyInputBlock: (key: number, block: boolean) => void;
+}
+//#endregion
+//#region src/managers/overridesManager.d.ts
+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;
+}
+//#endregion
+//#region src/utilities/types.d.ts
+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;
+	};
+};
+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"];
+};
+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;
+};
+type OverlayedAppKeybindsConfigMode = "toggle" | "hold";
+type OverlayedAppKeybindsConfigKey =
+	| "ControlLeft"
+	| "AltLeft"
+	| "ShiftLeft"
+	| "AltRight"
+	| "ControlRight"
+	| "ShiftRight"
+	| (string & {});
+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;
+	}
+>;
+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;
+};
+interface OverlayedAppWindowsModule
+	extends Pick<
+		RenderInterface$1,
+		| "on"
+		| "off"
+		| "once"
+		| "addListener"
+		| "prependListener"
+		| "prependOnceListener"
+		| "removeListener"
+		| "removeAllListeners"
+	> {
+	createWindow(options: RenderWindowConstructorOptions$1): RenderWindow$1;
+	getActiveGameInfo: () => ActiveGameInfo;
+}
+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;
+};
+interface OverlayedAppInputModule {
+	scope: (scopeName: string) => ReturnType<OverridesManager["scope"]>;
+	raw: OverlayedAppInputModuleRaw;
+}
+interface CortexEvents extends Record<string, unknown> {}
+interface OverlayedAppCortexModule {
+	track: <TEventName extends keyof CortexEvents>(name: TEventName, data: CortexEvents[TEventName]) => void;
+}
+interface OverlayedAppAdsModule {
+	registerWindow(
+		window: BrowserWindow,
+		options?: {
+			linkHandler?: {
+				allowHosts?: string[];
+			};
+		},
+	): void;
+}
+interface OverlayedAppLoggingModuleInfo extends Record<string, string | undefined> {
+	email?: string;
+	username?: string;
+	message?: string;
+	category?: string;
+	version?: string;
+}
+interface OverlayedAppLoggingModuleSubmitBugReportOptions {
+	/**
+	 * A key value record of additional files to include in the bug report.
+	 *
+	 * The key is the name of the file, and the value is the content of the file.
+	 */
+	additionalFiles?: Record<string, string>;
+}
+interface OverlayedAppLoggingModule {
+	/**
+	 * Returns a scoped logging instance. Each message will be prefixed with the scope name.
+	 *
+	 * ```ts
+	 * const scope = overlayed.log.scope("MyScope");
+	 * scope.info("Hello, world!");
+	 * // [2025-07-20 01:51:40.969] [log] [MyScope] Hello, world!
+	 * ```
+	 *
+	 * @param scopeName - The name of the scope.
+	 * @returns The logger scope.
+	 */
+	scope: (scopeName: string) => LoggerScope;
+	info: (message: string) => void;
+	warn: (message: string) => void;
+	error: (message: string) => void;
+	/**
+	 * Submits info you provide, app logs, overlayed logs, and any additional files you provide to be viewed
+	 * in your Overlayed dashboard.
+	 *
+	 * @param info - The information to include in the bug report.
+	 * @param options - The options to include in the bug report.
+	 * @returns The bug report id.
+	 */
+	submitBugReport: (
+		info: OverlayedAppLoggingModuleInfo,
+		options?: OverlayedAppLoggingModuleSubmitBugReportOptions,
+	) => Promise<
+		Result<
+			true,
+			{
+				message: string;
+				error: unknown;
+			}
+		>
+	>;
+}
+type OverlayedApp<TModule extends GameModule, TKeybind extends string> = OverlayedAppGameModules<TModule> &
+	OverlayedAppHandlers & {
+		keybinds: OverlayedAppKeybindModule<TKeybind>;
+		windows: OverlayedAppWindowsModule;
+		input: OverlayedAppInputModule;
+		ads: OverlayedAppAdsModule;
+		cortex: OverlayedAppCortexModule;
+		log: OverlayedAppLoggingModule;
+		/**
+		 * 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;
+	};
+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: typeof electron0;
+	/**
+	 * 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 version of the app.
+	 *
+	 * @deprecated
+	 */
+	version?: string;
+}
+//#endregion
+//#region src/utilities/overlayed.d.ts
+declare function overlayed<TModule extends GameModule, TShortcut extends string>(
+	options: OverlayedOptions<TModule, TShortcut>,
+): OverlayedApp<TModule, TShortcut>;
+//#endregion
+//#region src/managers/nativeModuleManager.d.ts
+declare function setFetchLatestTokenCallback(newFetchLatestToken: () => Promise<unknown> | undefined): void;
+//#endregion
+export {
+	type AccessLevel,
+	ActiveGameInfo,
+	type GameLaunchManagerEvents,
+	type KeybindSchemaEntry as KeybindConfig,
+	type KeyboardKeyEvent,
+	type MouseButtonEvent,
+	type OverlayedApp,
+	OverridesManagerScope,
+	type RenderInterface,
+	type RenderWindow,
+	type RenderWindowConstructorOptions,
+	type VirtualKey,
+	type WindowEvent,
+	overlayed,
+	setFetchLatestTokenCallback,
+	setUpdaterTokenResolver,
+};
+declare global {
+	namespace Electron {
+		interface BrowserWindow {
+			isShown(): boolean;
+		}
+	}
+}