@overlayed/app 0.7.2 → 0.8.0

package/dist/index.d.ts

@@ -28,6 +28,37 @@ 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 type CustomLoggerScope = ReturnType<typeof Logger.prototype.scope>;
 
 declare type ErrorEvents = ErrorPipeServerError | ErrorInvalidConfigFile;
@@ -79,7 +110,7 @@ declare type FatalEvents = FatalElevationMismatch;
 
 export declare type GameLaunchManagerEvents = {
     gameCloseInternal: (args: {
-        ravenGame: RavenGame;
+        ravenGame: GameModel;
         process: Process;
     }) => MaybePromise<void>;
     gameLaunch: (args: {
@@ -93,11 +124,18 @@ export declare type GameLaunchManagerEvents = {
         game: string;
     }) => MaybePromise<void>;
     gameReadyInternal: (args: {
-        ravenGame: RavenGame;
+        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>>;
@@ -371,16 +409,6 @@ export declare interface OverridesManagerScope {
     setKeyInputBlock: (key: number, block: boolean) => void;
 }
 
-declare interface RavenGame {
-    name: string;
-    identifier: RavenGameIdentifier;
-    executables: string[];
-    dlls_to_inject: string[];
-    version_pattern: string;
-}
-
-declare type RavenGameIdentifier = "siege" | "valorant";
-
 export class RenderInterface {
     		constructor(name: String, options?: { maxWindowCount?: number; eventQueueSize?: number; access?: AccessLevel }); // default: { maxWindowCount: 10, eventQueueSize: 200, access: AccessLevel.Default }
 
@@ -509,6 +537,10 @@ export interface RenderWindowConstructorOptions extends Electron.BrowserWindowCo
     		hasCursorOverride?: boolean; // default: true
     	}
 
+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,