@overlayed/app 1.3.6 → 1.3.9

package/dist/index.d.mts

@@ -1,90 +1,17 @@
-import * as arktype0 from "arktype";
+import * as _$arktype from "arktype";
 import { Module, Type } from "arktype";
 import EventEmitter$1 from "events";
-import "xior";
 import JSZip from "jszip";
-import * as electron0 from "electron";
+import * as _$electron from "electron";
 import { BrowserWindow, BrowserWindowConstructorOptions } from "electron";
 import { CancellationToken, 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 * 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
+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
@@ -124,10 +51,8 @@ declare class LoggerClass {
   private logToConsole;
 }
 declare const Logger: Singleton<typeof LoggerClass>;
-type CustomLoggerScope = ReturnType<typeof Logger.prototype.scope>;
-//#endregion
+type CustomLoggerScope = ReturnType<typeof Logger.prototype.scope>; //#endregion
 //#region src/consts.d.ts
-
 //#endregion
 //#region src/errorManager.d.ts
 type ErrorManagerEvent = {
@@ -249,16 +174,15 @@ declare const BaseEvent: Type<{
   type: string;
   creation_time: number;
 }>;
-type BaseEvent = typeof BaseEvent.infer;
-//#endregion
+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;
+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, {
@@ -285,16 +209,88 @@ type KeybindCallbacks = {
   down: KeybindDownCallback[];
   up: KeybindUpCallback[];
 };
-declare const KeybindSchema: arktype_internal_variants_object_ts0.ObjectType<{
+declare const KeybindSchema: _$arktype_internal_variants_object_ts0.ObjectType<{
   [x: string]: {
     keys: string[];
-    mode: (In: "toggle" | "hold") => arktype0.Out<"toggle" | "hold">;
+    mode: (In: "hold" | "toggle") => _$arktype.Out<"hold" | "toggle">;
   };
 }, {}>;
 type KeybindSchemaEntry = (typeof KeybindSchema.infer)[string];
 //#endregion
 //#region ../api/dist/index.d.ts
-
+//#region ../utils/dist/index.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 src/endpoints/applications/applications.d.ts
 //#endregion
 //#region src/endpoints/applications/crashDumps.d.ts
 type GameCrashReportId = Brand<string, "GameCrashReportId">;
@@ -401,21 +397,21 @@ declare class OverridesManager extends Manager {
 //#region src/module.d.ts
 declare function module(): {
   readonly key: "universal";
-  readonly events: arktype0.Module<{
+  readonly events: _$arktype.Module<{
     event: {
       game: "siege" | "tft";
-      type: "logged_in";
+      type: "module_loaded";
       creation_time: number;
       content: {
-        account_id: string;
+        game_version: string;
+        process_hash: string;
       };
     } | {
       game: "siege" | "tft";
-      type: "module_loaded";
+      type: "logged_in";
       creation_time: number;
       content: {
-        game_version: string;
-        process_hash: string;
+        account_id: string;
       };
     } | {
       game: "siege" | "tft";
@@ -462,8 +458,7 @@ declare function module(): {
       };
     };
   }>;
-};
-//#endregion
+}; //#endregion
 //#region src/events/loggedIn.d.ts
 //#endregion
 //#region src/managers/crashDumpManager.d.ts
@@ -506,13 +501,13 @@ type UpdateManagerEvents = {
 //#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"]> = {
+type OverlayedAppGameModuleListeners<TModule extends GameModule, TKey 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;
+    key: TKey;
   }>["events"]["event"]["infer"]>(cb: (data: TEvent) => void): void;
   /**
    * Listen to a specific event emitted by the module.
@@ -520,14 +515,14 @@ type OverlayedAppGameModuleListeners<TModule extends GameModule, TKey$1 extends
    * @param cb - The callback to call when the event is emitted.
    */
   on<TEvent extends Extract<TModule, {
-    key: TKey$1;
+    key: TKey;
   }>["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;
+    key: TKey;
   }>["events"]["event"]["infer"]>(cb: (data: TEvent) => void): void;
   /**
    * Stop listening to a specific event emitted by the module.
@@ -535,7 +530,7 @@ type OverlayedAppGameModuleListeners<TModule extends GameModule, TKey$1 extends
    * @param cb - The callback to stop listening to.
    */
   off<TEvent extends GameModuleEventInfer<Extract<TModule, {
-    key: TKey$1;
+    key: TKey;
   }>>, TEventType extends EventType<TEvent> = EventType<TEvent>>(event: TEventType, cb: EventCallback<TEvent, TEventType>): void;
   /**
    * Call this when you are ready to receive game events.
@@ -1103,7 +1098,7 @@ interface OverlayedOptions<TModule extends GameModule, TKeybind extends string,
    * const electron = require("electron");
    * ```
    */
-  electron: typeof electron0;
+  electron: typeof _$electron;
   /**
    * The application id, this can be found in the [Overlayed Dashboard](https://overlay.dev/settings/applications).
    */