@overlayed/app 0.0.0-canary-20260207042615

package/dist/index.d.mts

@@ -0,0 +1,1027 @@
+import * as arktype0 from "arktype";
+import { Module, Type } from "arktype";
+import EventEmitter$1 from "events";
+import "xior";
+import JSZip from "jszip";
+import * as electron0 from "electron";
+import { BrowserWindow, BrowserWindowConstructorOptions } from "electron";
+import { ProgressInfo, ProgressInfo as ProgressInfo$1, UpdateCheckResult, UpdateCheckResult as UpdateCheckResult$1, UpdateDownloadedEvent, UpdateInfo } from "electron-updater";
+import * as arktype_internal_variants_object_ts0 from "arktype/internal/variants/object.ts";
+import { KeyboardKeyEvent, MouseButtonEvent, RenderInterface, RenderInterface as RenderInterface$1, RenderWindow, RenderWindow as RenderWindow$1, RenderWindowConstructorOptions, RenderWindowConstructorOptions as RenderWindowConstructorOptions$1, VirtualKey, VirtualKey as VirtualKey$1, WindowEvent } from "@overlayed-gg/render-interface";
+
+//#region ../utils/dist/index.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type MaybeArray<T> = T | T[];
+//#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.
+*/
+type AnyBrand = Brand<unknown, any>;
+/**
+* `BaseOf` is a type that takes any branded type `B` and yields its base type.
+*/
+type BaseOf<B extends AnyBrand> = B["__witness__"];
+/**
+* A `Brander` is a function that takes a value of some base type and casts
+* that value to a branded type derived from said base type. It can be thought
+* of as the type of a "constructor", in the functional programming sense of
+* the word.
+*
+* @example
+* ```
+* type UserId = Brand<number, 'user'>;
+* // A Brander<UserId> would take a number and return a UserId
+* ```
+*/
+type Brander<B extends AnyBrand> = (underlying: BaseOf<B>) => B;
+/**
+* A generic function that, when given some branded type, can take a value with
+* the base type of the branded type, and cast that value to the branded type.
+* It fulfills the contract of a `Brander`.
+*
+* At runtime, this function simply returns the value as-is.
+*
+* @param underlying The value with a base type, to be casted
+* @return The same underlying value, but casted
+* @example
+* ```
+* type UserId = Brand<number, 'user'>;
+* const UserId: Brander<UserId> = identity;
+* ```
+*/
+//#endregion
+//#region ../utils-node/dist/index.d.mts
+//#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;
+  debug: (...args: unknown[]) => void;
+}
+declare class LoggerClass {
+  private fileLogger;
+  private path;
+  private appId;
+  private messageQueue;
+  fileName: string;
+  private _debug;
+  private silent;
+  constructor(fileName: string);
+  init(appId: string, debug?: boolean, silent?: boolean): 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;
+  private logToConsole;
+}
+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 ErrorSetupCortex extends ErrorManagerEvent {
+  code: "SETUP_CORTEX_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;
+  };
+}
+interface WarningEventBufferFull extends ErrorManagerEvent {
+  code: "EVENT_BUFFER_FULL";
+  data: {
+    summary: string;
+  };
+}
+type ErrorEvents = ErrorPipeServerError | ErrorInvalidConfigFile | ErrorSetupCortex;
+type WarningEvents = WarningInvalidEvent | WarningEventBufferFull;
+type FatalEvents = FatalElevationMismatch;
+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;
+  /**
+  * When true, the bundle will be created in debug mode.
+  * - Extra logs will occur
+  * - The bundles will be outputted as a zip **instead of uploading to the Overlayed platform**
+  *
+  * @default false
+  */
+  debug?: boolean;
+}
+interface BundleConfigBase {
+  /**
+  * The base directory to bundle from.
+  *
+  * @default location of the overlayed.config.ts file
+  */
+  baseDir?: string;
+  /**
+  * 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.mts
+//#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$1 extends string = string> {
+  key: TKey$1;
+  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<O extends Record<string, any> = {}> {
+  protected options: O | null;
+  protected logger: CustomLoggerScope;
+  initialized: boolean;
+  constructor(name: string);
+  init(options?: O): void;
+  destroy(): void;
+}
+//#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_variants_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/modules/releases.d.ts
+type ReleaseId = Brand<string, "release_id">;
+declare const ReleaseId: Brander<Brand<string, "release_id">>;
+type FeedbackType = "suggestion" | "bug_report";
+interface FeedbackRequestDataModel {
+  release_id?: ReleaseId;
+  type: FeedbackType;
+  cortex_user_id: string;
+  email?: string;
+  username?: string;
+  message?: string;
+  extra?: Record<string, unknown>;
+}
+interface FeedbackResponseModel {
+  id: Brand<string, FeedbackResponseModel>;
+}
+type FeedbackId = FeedbackResponseModel["id"];
+declare const FeedbackId: Brander<Brand<string, FeedbackResponseModel>>;
+//#endregion
+//#region src/endpoints/raven/games.d.ts
+interface GameModel {
+  name: string;
+  identifier: Brand<string, GameModel>;
+  modules: string[];
+  executables: string[];
+  allow_dll_injections: boolean;
+  has_render_support: boolean;
+}
+type GameIdentifier = GameModel["identifier"];
+declare const GameIdentifier: Brander<GameIdentifier>;
+//#endregion
+//#region src/endpoints/applications/notices.d.ts
+type NoticeType = "info" | "warning" | "error" | "critical";
+interface NoticeModel {
+  id: Brand<string, NoticeModel>;
+  message: string;
+  priority: number;
+  dismissible: boolean;
+  game?: GameIdentifier;
+  type?: NoticeType;
+  title?: string;
+  link?: string;
+  start_time?: string;
+  end_time?: string;
+}
+type NoticeId = NoticeModel["id"];
+//#endregion
+//#region src/managers/gameLaunchManager.d.ts
+type GameReadyEvent = {
+  game: string;
+  inGameRenderingSupported: boolean;
+};
+type GameLaunchEvent = {
+  game: GameIdentifier;
+  reject: () => void;
+};
+type GameCloseEvent = {
+  game: GameIdentifier;
+};
+type GameLaunchManagerEvents = {
+  gameLaunch: (args: GameLaunchEvent) => MaybePromise<boolean>;
+  gameClose: (args: GameCloseEvent) => MaybePromise<void>;
+  gameReady: (args: GameReadyEvent) => MaybePromise<void>;
+};
+//#endregion
+//#region ../native-managers/dist/index.d.mts
+//#region src/renderInterfaceManager.d.ts
+type RenderInterfaceName = "OGG_SIEGE";
+//#endregion
+//#region src/managers/overridesManager.d.ts
+interface OverridesManagerScope {
+  setGlobalCursorOverride: (override: boolean) => void;
+  setGlobalMouseBlock: (block: boolean) => void;
+  setGlobalKeyboardBlock: (block: boolean) => void;
+  setKeyInputBlock: (key: number, block: boolean) => void;
+}
+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 ../games/universal/dist/index.d.ts
+//#region src/module.d.ts
+declare function module(): {
+  readonly key: "universal";
+  readonly events: arktype0.Module<{
+    event: {
+      game: "siege" | "tft";
+      type: "logged_in";
+      creation_time: number;
+      content: {
+        account_id: string;
+      };
+    } | {
+      game: "siege" | "tft";
+      type: "module_loaded";
+      creation_time: number;
+      content: {
+        game_version: string;
+        process_hash: string;
+      };
+    } | {
+      game: "siege" | "tft";
+      type: "module_unloaded";
+      creation_time: number;
+    } | {
+      game: "siege" | "tft";
+      type: "unsupported_game_version";
+      creation_time: number;
+      content: {
+        game_version: string;
+        process_hash: string;
+      };
+    };
+    logged_in: {
+      game: "siege" | "tft";
+      type: "logged_in";
+      creation_time: number;
+      content: {
+        account_id: string;
+      };
+    };
+    module_loaded: {
+      game: "siege" | "tft";
+      type: "module_loaded";
+      creation_time: number;
+      content: {
+        game_version: string;
+        process_hash: string;
+      };
+    };
+    module_unloaded: {
+      game: "siege" | "tft";
+      type: "module_unloaded";
+      creation_time: number;
+    };
+    unsupported_game_version: {
+      game: "siege" | "tft";
+      type: "unsupported_game_version";
+      creation_time: number;
+      content: {
+        game_version: string;
+        process_hash: string;
+      };
+    };
+  }>;
+};
+//#endregion
+//#region src/events/loggedIn.d.ts
+//#endregion
+//#region src/managers/updateManager/updateManager.d.ts
+type UpdateManagerEvents = {
+  error: {
+    error: Error;
+    message?: string;
+  };
+  checkingForUpdates: {};
+  updateNotAvailable: {
+    info: UpdateInfo;
+  };
+  updateAvailable: {
+    info: UpdateInfo;
+  };
+  updateDownloaded: {
+    event: UpdateDownloadedEvent;
+  };
+  updateCancelled: {
+    info: UpdateInfo;
+  };
+  downloadProgress: {
+    info: ProgressInfo$1;
+  };
+  /**
+   * Emitted when the access token fetcher returns an invalid token.
+   *
+   * We strongly recommend logging the user out in this case, as it likely means
+   * their account no longer has access to the private channel.
+   */
+  authTokenInvalid: {};
+};
+//#endregion
+//#region src/utilities/types.d.ts
+type UniversalGameModule = ReturnType<typeof module>;
+type OverlayedAppGameModules<TModule extends GameModule> = { [TKey in TModule["key"]]: OverlayedAppGameModuleListeners<TModule, TKey> } & { [TKey in UniversalGameModule["key"]]: OverlayedAppGameModuleListeners<UniversalGameModule, TKey> };
+type OverlayedAppGameModuleListeners<TModule extends GameModule, TKey$1 extends TModule["key"] = TModule["key"]> = {
+  /**
+   * Listen to any event emitted by the module.
+   * @param cb - The callback to call when any event is emitted.
+   */
+  onAny<TEvent extends Extract<TModule, {
+    key: TKey$1;
+  }>["events"]["event"]["infer"]>(cb: (data: TEvent) => void): void;
+  /**
+   * Listen to a specific event emitted by the module.
+   * @param event - The event to listen to.
+   * @param cb - The callback to call when the event is emitted.
+   */
+  on<TEvent extends Extract<TModule, {
+    key: TKey$1;
+  }>["events"]["event"]["infer"], TEventType extends EventType<TEvent> = EventType<TEvent>>(event: TEventType, cb: EventCallback<TEvent, TEventType>): void;
+  /**
+   * Stop listening to any event emitted by the module.
+   * @param cb - The callback to stop listening to.
+   */
+  offAny<TEvent extends Extract<TModule, {
+    key: TKey$1;
+  }>["events"]["event"]["infer"]>(cb: (data: TEvent) => void): void;
+  /**
+   * Stop listening to a specific event emitted by the module.
+   * @param event - The event to stop listening to.
+   * @param cb - The callback to stop listening to.
+   */
+  off<TEvent extends GameModuleEventInfer<Extract<TModule, {
+    key: TKey$1;
+  }>>, TEventType extends EventType<TEvent> = EventType<TEvent>>(event: TEventType, cb: EventCallback<TEvent, TEventType>): void;
+  /**
+   * Call this when you are ready to receive game events.
+   *
+   * Before this is called, any incoming events will be stored to be emitted when this method gets called.
+   */
+  readyForGameEvents: () => void;
+};
+type OverlayedAppHandlersMapping = GameLaunchManagerEvents & {
+  error: (data: ErrorEvents) => void;
+  warning: (data: WarningEvents) => void;
+  fatal: (data: FatalEvents) => void;
+};
+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][number]) => 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 ActiveGameInfo = {
+  isConnected: boolean;
+  resolution: {
+    width: number;
+    height: number;
+  };
+};
+interface OverlayedAppWindowsModule extends Pick<RenderInterface$1, "on" | "off" | "once" | "addListener" | "prependListener" | "prependOnceListener" | "removeListener" | "removeAllListeners"> {
+  /**
+   * Returns the production site url configured in the [Overlayed Dashboard](https://overlay.dev/settings).
+   *
+   * @returns The production site url.
+   */
+  getProductionSiteUrl: () => URL;
+  /**
+   * Creates a new window. All windows must be created with this method.
+   *
+   * @param options The options for the window.
+   * @returns The created window.
+   */
+  createWindow(options: BrowserWindowConstructorOptions): BrowserWindow;
+  /**
+   * Creates a new in-game window. All in-game windows must be created with this method.
+   *
+   * @param options The options for the window.
+   * @returns The created window.
+   */
+  createInGameWindow(options: RenderWindowConstructorOptions$1): RenderWindow$1;
+  /**
+   * Returns information about the currently active game.
+   *
+   * @returns The active game info.
+   */
+  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$1, 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$1): 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;
+}
+type OverlayedAppLoggingModuleSubmitFeedbackInfo = Omit<FeedbackRequestDataModel, "app_version" | "app_channel" | "type" | "cortex_user_id">;
+interface OverlayedAppLoggingModuleSubmitFeedbackOptions {
+  /**
+   * A key value record of additional files to include in the feedback.
+   *
+   * The key is the name of the file, and the value is the content of the file.
+   */
+  additionalFiles?: Record<string, string>;
+  /**
+   * When true, silences logs
+   *
+   * @default false
+   */
+  silent?: boolean;
+}
+/**
+ * The logging module.
+ * - This module is used to log messages to the console and file.
+ * - Logs are stored in `%appdata%/overlayed/<appId>/logs/app.log`.
+ * - One log file is created per day, and is deleted after 7 days.
+ * - Enabling debug mode will show in the overlayed options .debug logs, and internal overlayed logs.
+ *
+ * @example
+ * ```ts
+ * const scope = overlayed.log.scope("MyScope");
+ * scope.info("Hello, world!");
+ * // [2025-07-20 01:51:40.969] [info] [MyScope] Hello, world!
+ * ```
+ */
+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;
+  /**
+   * Log a message to the console if debug mode is enabled.
+   *
+   * @param message - The message to log.
+   */
+  debug: (message: string) => void;
+  /**
+   * Submits info you provide, app logs, overlayed logs, and any additional files you provide to be viewed
+   * in your Overlayed dashboard.
+   *
+   * @throws Error if files fail to zip
+   * @throws ApiError if the request fails
+   *
+   * @param type - The type of feedback to submit.
+   * @param info - The information to include in the feedback.
+   * @param options - The options to include in the feedback.
+   * @returns The unique feedback identifier, or undefined if the request fails.
+   */
+  submitFeedback: (type: FeedbackType, info: OverlayedAppLoggingModuleSubmitFeedbackInfo, options?: OverlayedAppLoggingModuleSubmitFeedbackOptions) => Promise<FeedbackId | undefined>;
+  /**
+   * Get the zip of logs sent via the submitFeedback method.
+   *
+   * ```ts
+   * const zip = overlayed.logger.getLogsZip();
+   *
+   * // prep to send off to a server
+   * const zipBase64 = await zip.generateAsync({ type: "base64" });
+   * ```
+   *
+   * @param options - The options to include in the zip.
+   * @returns Returns a zip of app and overlayed logs, and any additional files you provide.
+   */
+  getLogsZip: (options?: OverlayedAppLoggingModuleSubmitFeedbackOptions) => JSZip;
+}
+type OverlayedAppNoticeHandlerMapping = {
+  /**
+   * Emitted when:
+   * - Notices are automatically fetched from the API
+   * - A notice is dismissed
+   * - `gameReady` is triggered
+   *
+   * The `notices` will never include dismissed notices.
+   *
+   * @param data - The data containing the notices.
+   */
+  noticesUpdated: (data: {
+    notices: NoticeModel[];
+  }) => void;
+};
+/**
+ * Module to show notices to the user.
+ *
+ * Create a notice in the [Overlayed Dashboard](https://overlay.dev/notices).
+ */
+interface OverlayedAppNoticesModule {
+  on: <TEvent extends keyof OverlayedAppNoticeHandlerMapping = keyof OverlayedAppNoticeHandlerMapping>(event: TEvent, cb: OverlayedAppNoticeHandlerMapping[TEvent]) => void;
+  off: <TEvent extends keyof OverlayedAppNoticeHandlerMapping = keyof OverlayedAppNoticeHandlerMapping>(event: TEvent, cb: OverlayedAppNoticeHandlerMapping[TEvent]) => void;
+  /**
+   * Dismiss a notice. This will remove it from the list of notices returned by `getNotices` and the `noticesUpdated` event.
+   *
+   * Notices are stored in a `notice.json` file in your app directory.
+   * A maximum of 100 dismissed notices are stored. Once this limit is reached, the oldest dismissed notice is removed.
+   *
+   * When passing a notice id that is not dismissible, nothing will happen.
+   *
+   * @param noticeId - The id of the notice to dismiss.
+   */
+  dismissNotice: (noticeId: NoticeId) => void;
+  /**
+   * Returns notices that are not dismissed and not expired.
+   *
+   * Notices for the currently launched games are included, and any notices without a game attached are included.
+   *
+   * @returns an array of notices
+   */
+  getNotices: () => NoticeModel[];
+}
+type OverlayedAppUpdateHandlerMapping = { [K in keyof UpdateManagerEvents]: (data: UpdateManagerEvents[K]) => void };
+interface OverlayedAppUpdateModule {
+  site: OverlayedAppSiteModule;
+  on: <TEvent extends keyof OverlayedAppUpdateHandlerMapping = keyof OverlayedAppUpdateHandlerMapping>(event: TEvent, cb: OverlayedAppUpdateHandlerMapping[TEvent]) => void;
+  off: <TEvent extends keyof OverlayedAppUpdateHandlerMapping = keyof OverlayedAppUpdateHandlerMapping>(event: TEvent, cb: OverlayedAppUpdateHandlerMapping[TEvent]) => void;
+  /**
+   * Checks for updates.
+   * @returns Promise<UpdateCheckResult | null>
+   */
+  checkForUpdates: () => Promise<UpdateCheckResult$1 | null>;
+  /**
+   * Sets the function to fetch the access token.
+   * This function should return the access token or null if the channel is public.
+   *
+   * @param accessTokenFetcher - The function to fetch the access token. Optionally pass the new channel to fetch the access token for.
+   */
+  setAccessTokenFetcher: (accessTokenFetcher: (newChannel: string) => Promise<string | null>) => void;
+  /**
+   * Switches the channel for the next checkForUpdates call.
+   *
+   * Example code:
+   *
+   * ```ts
+   * function changeChannel(newChannel: string) {
+   * 	await overlayed.updater.switchChannel(newChannel);
+   * 	await overlayed.updater.checkForUpdates();
+   * }
+   * ```
+   *
+   * @param channel - The channel to switch to.
+   */
+  switchChannel: (channel: string) => Promise<UpdateCheckResult$1 | null>;
+  /**
+   * Restarts the app and installs the update after it has been downloaded.
+   * It should only be called after `update-downloaded` has been emitted.
+   *
+   * **Note:** `autoUpdater.quitAndInstall()` will close all application windows first and only emit `before-quit` event on `app` after that.
+   * This is different from the normal quit event sequence.
+   *
+   * @param isSilent *windows-only* Runs the installer in silent mode. Defaults to `false`.
+   * @param isForceRunAfter Run the app after finish even on silent install. Not applicable for macOS.
+   * Ignored if `isSilent` is set to `false`(In this case you can still set `autoRunAppAfterInstall` to `false` to prevent run the app after finish).
+   *
+   * @throws Error if `canUpdate` is false.
+   */
+  quitAndInstall: (isSilent?: boolean, isForceRunAfter?: boolean) => void;
+  /**
+   * Checks if the user can update.
+   *
+   * @example
+   * ```ts
+   * const [canUpdate, denialReason] = overlayed.updater.canUpdate();
+   * ```
+   *
+   * @returns `[true, null]` if the user can update, `[false, reason]` if the user cannot update.
+   *
+   * Reasons:
+   *   	- "User is in game"
+   */
+  canUpdate: () => [true, null] | [false, string];
+}
+interface OverlayedAppApplicationModule {
+  /**
+   * Get the application channel.
+   * @returns string
+   */
+  getChannel: () => string;
+  /**
+   * Get the application version.
+   * @returns string
+   */
+  getVersion: () => string;
+  /**
+   * Get the application release id.
+   * @returns string | null
+   */
+  getReleaseId: () => string | null;
+}
+type OverlayedAppSiteHandlerMapping = {
+  /**
+   * Emitted when a new site version is available.
+   *
+   * @example
+   * ```ts
+   * overlayed.site.on("siteUpdateReady", () => {
+   *   showUserSiteUpdateButton();
+   * });
+   *
+   * onUserClickSiteUpdateButton(() => {
+   *   overlayed.site.allowSiteUpdateOnNextLoad();
+   *   allWindows.forEach((window) => {
+   *     window.webContents.reload();
+   *   });
+   * });
+   *
+   * @param data - releaseId and version
+   * @returns
+   */
+  siteUpdateReady: (data: {
+    releaseId: ReleaseId;
+    version: string;
+  }) => void;
+};
+interface OverlayedAppSiteModule {
+  on: <TEvent extends keyof OverlayedAppSiteHandlerMapping = keyof OverlayedAppSiteHandlerMapping>(event: TEvent, cb: OverlayedAppSiteHandlerMapping[TEvent]) => void;
+  off: <TEvent extends keyof OverlayedAppSiteHandlerMapping = keyof OverlayedAppSiteHandlerMapping>(event: TEvent, cb: OverlayedAppSiteHandlerMapping[TEvent]) => void;
+  /**
+   * If an update is available, the next time BrowserWindow#loadURL is called, the new site version will be used.
+   *
+   * Must be called only after `siteUpdateReady` has been emitted.
+   *
+   * @example
+   * ```ts
+   * overlayed.site.on("siteUpdateReady", () => {
+   *   showUserSiteUpdateButton();
+   * });
+   *
+   * onUserClickSiteUpdateButton(() => {
+   *   overlayed.site.allowSiteUpdateOnNextLoad();
+   *   allWindows.forEach((window) => {
+   *     window.webContents.reload();
+   *   });
+   * });
+   * ```
+   */
+  allowSiteUpdateOnNextLoad: () => void;
+}
+type OverlayedApp<TModule extends GameModule, TKeybind extends string> = OverlayedAppGameModules<TModule> & OverlayedAppHandlers & {
+  keybinds: OverlayedAppKeybindModule<TKeybind>;
+  windows: OverlayedAppWindowsModule;
+  input: OverlayedAppInputModule;
+  ads: OverlayedAppAdsModule;
+  cortex: OverlayedAppCortexModule;
+  log: OverlayedAppLoggingModule;
+  notices: OverlayedAppNoticesModule;
+  updater: OverlayedAppUpdateModule;
+  application: OverlayedAppApplicationModule;
+  /**
+   * Returns true if any monitored processes are running.
+   *
+   * Useful for stopping the overlay from updating when the game is running.
+   *
+   * @returns True if any monitored processes are running.
+   */
+  hasAnyActiveProcesses: () => boolean;
+  /**
+   * Returns true if any monitored games are running.
+   *
+   * @returns True if any monitored games are running.
+   */
+  hasAnyActiveGames: () => 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://overlay.dev/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;
+  /**
+   * When true, the overlay will be loaded in debug mode.
+   *
+   * @default false
+   */
+  debug?: boolean;
+  /**
+   * When true, internal overlayed logs will not be logged to the console.
+   *
+   * @default true
+   */
+  silent?: boolean;
+  /**
+   * Site module configuration.
+   */
+  site?: {
+    /**
+     * When true, users will not update automatically when a new site version is available.
+     *
+     * If you'd prefer users to have to click an "update" button when a new site version,
+     * set this to true.
+     *
+     * @default false
+     */
+    manualUpdates?: boolean;
+  };
+}
+//#endregion
+//#region src/utilities/overlayed.d.ts
+declare function overlayed<TModule extends GameModule, TShortcut extends string>(optionsRaw: OverlayedOptions<TModule, TShortcut>): OverlayedApp<TModule, TShortcut>;
+//#endregion
+export { type ActiveGameInfo, type BundleAppConfig, type BundleSiteConfig, type ErrorEvents, type FatalEvents, type FeedbackId, type FeedbackType, type GameCloseEvent, type GameLaunchEvent, type GameReadyEvent, type KeybindSchemaEntry as KeybindConfig, type KeyboardKeyEvent, type LoggerScope, type MouseButtonEvent, type NoticeId, type NoticeModel, type NoticeType, type OverlayedApp, type OverlayedConfig, type OverridesManagerScope, type ProgressInfo, RenderInterface, type RenderWindow, type RenderWindowConstructorOptions, type UpdateCheckResult, VirtualKey, type WarningEvents, type WindowEvent, defineConfig, overlayed };
+				declare global {
+					namespace Electron {
+						interface BrowserWindow {
+							isShown(): boolean;
+						}
+					}
+				}
+