@overlayed/app 0.13.1 → 0.14.1

package/dist/index.d.ts

@@ -1,35 +1,202 @@
+import * as arktype0 from "arktype";
+import { Module, Type } from "arktype";
+import EventEmitter$1 from "events";
+import "xior";
 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";
+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";
 
+//#region ../utils/dist/index.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type MaybeArray<T> = T | T[];
+type Result<T, E = string> = [T, undefined] | [undefined, E];
+//#endregion
+//#region src/utilities.d.ts
+
+//#endregion
+//#region src/brand.d.ts
+/**
+* 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> }
+* ```
+*/
+type Brand<Base, Branding, ReservedName extends string = "__type__"> = Base & { [K in ReservedName]: Branding } & {
+  __witness__: Base;
+};
+/**
+* An `AnyBrand` is a branded type based on any base type branded with any
+* branding type. By itself it is not useful, but it can act as type constraint
+* when manipulating branded types in general.
+*/
+//#endregion
+//#region ../utils-node/dist/index.d.ts
+//#endregion
+//#region src/asSingleton.d.ts
+type Singleton<T extends new (...args: any[]) => any> = T & {
+  getInstance: () => InstanceType<T>;
+  clearInstance: () => void;
+};
+//#endregion
+//#region src/logger.d.ts
+interface LoggerScope {
+  scope: (name: string) => LoggerScope;
+  error: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+  log: (...args: unknown[]) => void;
+}
+declare class LoggerClass {
+  private fileLogger;
+  private path;
+  private appId;
+  private messageQueue;
+  fileName: string;
+  constructor(fileName: string);
+  init(appId: string): void;
+  scope(name: string): LoggerScope;
+  error(...args: unknown[]): void;
+  warn(...args: unknown[]): void;
+  info(...args: unknown[]): void;
+  debug(...args: unknown[]): void;
+  log(...args: unknown[]): void;
+  private handle;
+}
+declare const Logger: Singleton<typeof LoggerClass>;
+type CustomLoggerScope = ReturnType<typeof Logger.prototype.scope>;
+//#endregion
+//#region src/consts.d.ts
+
+//#endregion
+//#region src/errorManager.d.ts
+type ErrorManagerEvent = {
+  code: string;
+  message: string;
+  data: Record<string, any>;
+  timestamp: number;
+};
+interface FatalElevationMismatch extends ErrorManagerEvent {
+  code: "ELEVATION_MISMATCH";
+  data: {
+    appElevated: boolean;
+    gameElevated: boolean;
+  };
+}
+interface ErrorPipeServerError extends ErrorManagerEvent {
+  code: "PIPE_SERVER_ERROR";
+  data: {
+    error: unknown;
+  };
+}
+interface ErrorInvalidConfigFile extends ErrorManagerEvent {
+  code: "INVALID_CONFIG_FILE";
+  data: {
+    issues: string[];
+    filePath: string;
+    data: unknown;
+  };
+}
+interface WarningInvalidEvent extends ErrorManagerEvent {
+  code: "INVALID_EVENT";
+  data: {
+    summary: string;
+  };
+}
+type ErrorEvents = ErrorPipeServerError | ErrorInvalidConfigFile;
+type WarningEvents = WarningInvalidEvent;
+type FatalEvents = FatalElevationMismatch;
+type ErrorManagerEvents = {
+  fatal: FatalEvents;
+  error: ErrorEvents;
+  warning: WarningEvents;
+};
+interface OverlayedConfig {
+  /**
+  * Your Overlayed application ID.
+  */
+  applicationId: string;
+  /**
+  * The bundle config for your electron app.
+  */
+  app: BundleAppConfig;
+  /**
+  * The optional bundle config for your site.
+  */
+  site?: BundleSiteConfig;
+}
+interface BundleConfigBase {
+  /**
+  * String or array of string [glob](https://www.npmjs.com/package/glob) patterns to bundle.
+  *
+  * `package.json` is always included.
+  */
+  include: MaybeArray<string>;
+  /**
+  * String or array of string [glob](https://www.npmjs.com/package/glob) patterns to exclude from the bundle.
+  *
+  * `/installer` is always excluded.
+  */
+  exclude?: string | string[];
+}
+interface BundleAppConfig extends BundleConfigBase {}
+interface BundleSiteConfig extends BundleConfigBase {}
+declare function defineConfig(config: OverlayedConfig): OverlayedConfig;
+//#endregion
+//#region ../events/dist/index.d.ts
+//#endregion
+//#region src/utils.d.ts
+declare const BaseEvent: Type<{
+  game: string;
+  type: string;
+  creation_time: number;
+}>;
+type BaseEvent = typeof BaseEvent.infer;
+//#endregion
+//#region src/types.d.ts
+type EventType<TEvent extends BaseEvent> = TEvent["type"];
+type GameModuleEvent<TEvents extends Record<string, BaseEvent>> = TEvents & {
+  event: BaseEvent;
+};
+type GameModuleEventInfer<TModule extends GameModule> = TModule["events"]["event"]["infer"];
+interface GameModule<TEvents extends Record<string, BaseEvent> = Record<string, BaseEvent>, TKey extends string = string> {
+  key: TKey;
+  events: Module<GameModuleEvent<TEvents>>;
+}
+type EventCallback<TEvent extends BaseEvent, TEventType extends EventType<TEvent>> = (event: Extract<TEvent, {
+  type: TEventType;
+}>) => void;
+//#endregion
 //#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;
+  protected logger: CustomLoggerScope;
+  initialized: boolean;
+  constructor(name: string);
+  init(): void;
+  destroy(): void;
 }
 /** This should be kept in sync with Manager */
 //#endregion
@@ -38,427 +205,358 @@ type KeybindPressedCallback = () => string | void;
 type KeybindDownCallback = () => string | void;
 type KeybindUpCallback = () => void;
 type KeybindCallbacks = {
-	toggle?: KeybindPressedCallback;
-	down?: KeybindDownCallback;
-	up?: KeybindUpCallback;
+  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">;
-		};
-	},
-	{}
->;
+declare const KeybindSchema: arktype_internal_methods_object_ts0.ObjectType<{
+  [x: string]: {
+    keys: string[];
+    mode: (In: "toggle" | "hold") => arktype0.Out<"toggle" | "hold">;
+  };
+}, {}>;
 type KeybindSchemaEntry = (typeof KeybindSchema.infer)[string];
 //#endregion
+//#region ../api/dist/index.d.ts
+//#endregion
+//#region src/endpoints/raven/games.d.ts
+interface GameModel {
+  name: string;
+  identifier: Brand<string, GameModel>;
+  modules: string[];
+  executables: string[];
+}
+//#endregion
+//#region src/instances.d.ts
+declare function setUpdaterTokenResolver(newTokenResolver: () => string | undefined): void;
+//#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>;
+  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;
-	};
+  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;
+  setGlobalCursorOverride: (override: boolean) => void;
+  setGlobalMouseBlock: (block: boolean) => void;
+  setGlobalKeyboardBlock: (block: boolean) => void;
+  setKeyInputBlock: (key: number, block: boolean) => void;
 }
 //#endregion
+//#region ../native-managers/dist/index.d.ts
+//#region src/renderInterfaceManager.d.ts
+type RenderInterfaceName = "OGG_SIEGE";
+//#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;
+  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 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"];
+  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;
+  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;
+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;
+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;
+  /**
+   * 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;
+  scope: (scopeName: string) => ReturnType<OverridesManager["scope"]>;
+  raw: OverlayedAppInputModuleRaw;
 }
-interface CortexEvents extends Record<string, unknown> {}
+interface CortexEvents {}
 interface OverlayedAppCortexModule {
-	track: <TEventName extends keyof CortexEvents>(name: TEventName, data: CortexEvents[TEventName]) => void;
+  track: <TEventName extends keyof CortexEvents>(name: TEventName, data: CortexEvents[TEventName]) => void;
 }
 interface OverlayedAppAdsModule {
-	registerWindow(
-		window: BrowserWindow,
-		options?: {
-			linkHandler?: {
-				allowHosts?: string[];
-			};
-		},
-	): void;
+  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;
+  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>;
+  /**
+   * 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;
-			}
-		>
-	>;
+  /**
+   * 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;
-	};
+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;
+  /**
+   * 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>;
+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;
-		}
-	}
-}
+export { type AccessLevel, ActiveGameInfo, type BundleAppConfig, type BundleSiteConfig, type GameLaunchManagerEvents, type KeybindSchemaEntry as KeybindConfig, type KeyboardKeyEvent, type MouseButtonEvent, type OverlayedApp, type OverlayedConfig, OverridesManagerScope, type RenderInterface, type RenderWindow, type RenderWindowConstructorOptions, type VirtualKey, type WindowEvent, defineConfig, overlayed, setFetchLatestTokenCallback, setUpdaterTokenResolver };
+				declare global {
+					namespace Electron {
+						interface BrowserWindow {
+							isShown(): boolean;
+						}
+					}
+				}
+