@decky/ui 4.15.1 → 4.16.0

package/dist/components/Dropdown.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode, FC } from 'react';
 import { ItemProps } from './Item';
-import type { ContextMenuPositionOptions } from './Menu';
+import type { ContextMenuCreationOptions } from './Menu';
 export interface SingleDropdownOption {
     data: any;
     label: ReactNode;
@@ -19,7 +19,7 @@ export interface DropdownProps {
     onMenuWillOpen?(showMenu: () => void): void;
     onMenuOpened?(): void;
     onChange?(data: SingleDropdownOption): void;
-    contextMenuPositionOptions?: ContextMenuPositionOptions;
+    contextMenuPositionOptions?: ContextMenuCreationOptions;
     menuLabel?: string;
     strDefaultLabel?: string;
     renderButtonValue?(element: ReactNode): ReactNode;

package/dist/components/FooterLegend.d.ts

@@ -30,6 +30,12 @@ export declare enum GamepadButton {
     STEAM_GUIDE = 27,
     STEAM_QUICK_MENU = 28
 }
+export declare enum EFocusSource {
+    GAMEPAD = 0,
+    KEYBOARD = 1,
+    APPLICATION = 2,
+    BROWSER = 3
+}
 export declare enum NavEntryPositionPreferences {
     FIRST = 0,
     LAST = 1,
@@ -38,9 +44,9 @@ export declare enum NavEntryPositionPreferences {
     PREFERRED_CHILD = 4
 }
 export interface GamepadEventDetail {
-    button: number;
+    button: GamepadButton;
     is_repeat?: boolean;
-    source: number;
+    source: EFocusSource;
 }
 export declare type ActionDescriptionMap = {
     [key in GamepadButton]?: ReactNode;

package/dist/components/FooterLegend.js

@@ -30,6 +30,13 @@ export var GamepadButton;
     GamepadButton[GamepadButton["STEAM_GUIDE"] = 27] = "STEAM_GUIDE";
     GamepadButton[GamepadButton["STEAM_QUICK_MENU"] = 28] = "STEAM_QUICK_MENU";
 })(GamepadButton || (GamepadButton = {}));
+export var EFocusSource;
+(function (EFocusSource) {
+    EFocusSource[EFocusSource["GAMEPAD"] = 0] = "GAMEPAD";
+    EFocusSource[EFocusSource["KEYBOARD"] = 1] = "KEYBOARD";
+    EFocusSource[EFocusSource["APPLICATION"] = 2] = "APPLICATION";
+    EFocusSource[EFocusSource["BROWSER"] = 3] = "BROWSER";
+})(EFocusSource || (EFocusSource = {}));
 export var NavEntryPositionPreferences;
 (function (NavEntryPositionPreferences) {
     NavEntryPositionPreferences[NavEntryPositionPreferences["FIRST"] = 0] = "FIRST";

package/dist/components/Menu.d.ts

@@ -1,10 +1,6 @@
-import { FC, ReactNode } from 'react';
-import { FooterLegendProps } from './FooterLegend';
-interface PopupCreationOptions {
-    bCreateHidden?: boolean;
-    bModal?: boolean;
-    title?: string;
-}
+import type { FC, ReactNode } from 'react';
+import type { PopupCreationOptions } from '../globals/stores/popupmanager';
+import type { FooterLegendProps } from './FooterLegend';
 interface MonitorOptions {
     targetMonitor: {
         flMonitorScale: number;
@@ -15,7 +11,7 @@ interface MonitorOptions {
     };
     flGamepadScale: number;
 }
-export interface ContextMenuPositionOptions extends PopupCreationOptions, Partial<MonitorOptions> {
+export interface ContextMenuCreationOptions extends PopupCreationOptions, Partial<MonitorOptions> {
     bAlwaysOnTop?: boolean;
     bDisableMouseOverlay?: boolean;
     bDisablePopTop?: boolean;
@@ -39,7 +35,7 @@ interface ContextMenuInstance {
     Hide(): void;
     Show(): void;
 }
-export declare const showContextMenu: (children: ReactNode, parent?: EventTarget, options?: ContextMenuPositionOptions) => ContextMenuInstance;
+export declare const showContextMenu: (children: ReactNode, parent?: EventTarget, options?: ContextMenuCreationOptions) => ContextMenuInstance;
 export interface MenuProps extends FooterLegendProps {
     label: string;
     onCancel?(): void;

package/dist/components/Modal.d.ts

@@ -1,6 +1,7 @@
-import { FC, ReactNode } from 'react';
+import type { FC, ReactNode } from 'react';
+import type { BrowserContext } from '../globals/shared';
 export interface ShowModalProps {
-    browserContext?: unknown;
+    browserContext?: BrowserContext;
     bForcePopOut?: boolean;
     bHideActionIcons?: boolean;
     bHideMainWindowForPopouts?: boolean;

package/dist/globals/index.d.ts

@@ -1,2 +1,25 @@
-export * from './SteamClient';
-export * from './stores';
+import type { SteamClient } from './steam-client';
+import type { CApp, CAppDetailsStore, CAppStore, CBadgeStore, CCollectionStore, CConsoleStore, CFocusNavController, CFriendStore, CGameRecordingStore, CLibraryUIStore, CLocalizationManager, CMainWindowBrowserManager, CNotificationStore, CPopupManager, CSecurityStore, CSettingsStore, CSteamUIStore, CURLStore } from './stores';
+declare global {
+    interface Window {
+        App: CApp;
+        appStore: CAppStore;
+        appDetailsStore: CAppDetailsStore;
+        badgeStore: CBadgeStore;
+        collectionStore: CCollectionStore;
+        ConsoleStore: CConsoleStore;
+        FocusNavController: CFocusNavController;
+        friendStore: CFriendStore;
+        g_GRS: CGameRecordingStore;
+        g_PopupManager: CPopupManager;
+        LocalizationManager: CLocalizationManager;
+        MainWindowBrowserManager: CMainWindowBrowserManager;
+        NotificationStore: CNotificationStore;
+        securitystore: CSecurityStore;
+        settingsStore: CSettingsStore;
+        SteamClient: SteamClient;
+        SteamUIStore: CSteamUIStore;
+        uiStore: CLibraryUIStore;
+        urlStore: CURLStore;
+    }
+}

package/dist/globals/index.js

@@ -1,2 +1 @@
-export * from './SteamClient';
-export * from './stores';
+export {};

package/dist/globals/shared/cm.d.ts

@@ -0,0 +1,112 @@
+import type { JsPbMessageClass, OperationResponse } from '../steam-client/shared';
+import type { CBaseProtoBufMsg, CCallbackList, Unsubscribable } from './interfaces';
+import type { CSteamID } from './steamid';
+type Callback_t = (msg: CBaseProtoBufMsg) => void;
+export type EMsg_t = number;
+interface ReportErrorOptions {
+    cCallsitesToIgnore: number;
+    bIncludeMessageInIdentifier: boolean;
+    error: Error;
+    strComponentStack: string;
+}
+interface ReportErrorResult {
+    identifier: string;
+    identifierHash: string;
+    message: string[];
+}
+interface ErrorReportingStore {
+    m_bEnabled: boolean;
+    m_bInitialized: boolean;
+    m_bReportingPaused: boolean;
+    m_fnGetReportingInterval: () => number;
+    m_rgErrorQueue: Error[];
+    m_sendTimer: number | null;
+    m_strProduct: string;
+    m_strVersion: string;
+    m_transport: ServiceTransport;
+    BIsBlacklisted(error: Error): boolean;
+    QueueSend(error: Error): void;
+    ReportError(error: Error, options?: Partial<ReportErrorOptions>): Promise<ReportErrorResult | null>;
+    SendErrorReport(error: Error): void;
+    SendErrorReports(errors: Error[]): void;
+}
+export interface ServiceTransport {
+    MakeReady(): Promise<OperationResponse>;
+    SendMsg(target_job_name: string, msg: CBaseProtoBufMsg, protoMsg: any): CBaseProtoBufMsg;
+    SendNotification(target_job_name: string, msg: CBaseProtoBufMsg): boolean;
+}
+interface ServiceHandler<T extends Callback_t> {
+    invoke: T;
+    msgClass: JsPbMessageClass;
+}
+interface ServiceMethod {
+    name: string;
+    request: any;
+}
+interface ServiceRegistrar<T extends Callback_t> {
+    invoke: T;
+    unregister(): void;
+}
+interface MessageHandlers {
+    m_mapCallbacks: Map<EMsg_t, ServiceHandler<any>[]>;
+    m_mapServiceMethodHandlers: Map<string, ServiceHandler<any>[]>;
+    m_rgRegisteredEMsgs: EMsg_t[];
+    m_rgRegisteredServiceMethodHandlers: string[];
+    AddCallback<T extends Callback_t>(msg: EMsg_t, msgClass: any | undefined, callback: T): ServiceRegistrar<T>;
+    AddServiceMethodHandler<T extends Callback_t>(method: ServiceMethod, callback: T): ServiceRegistrar<T>;
+    AddServiceNotificationHandler<T extends Callback_t>(msg: EMsg_t, callback: T): ServiceRegistrar<T>;
+    DispatchMsgToHandlers(msg: CBaseProtoBufMsg, callback: (msg: CBaseProtoBufMsg) => void): boolean;
+    InstallErrorReportingStore(store: ErrorReportingStore): void;
+    RegisterBaseEMessageHandler<T extends Callback_t>(msg: EMsg_t, callback: T): ServiceRegistrar<T>;
+    RegisterEMessageAction<T extends Callback_t>(msg: EMsg_t, msgClass: any | undefined, callback: T): ServiceRegistrar<T>;
+    RegisterEMessageHandler<T extends Callback_t>(msg: EMsg_t, msgClass: any | undefined, callback: T): ServiceRegistrar<T>;
+    RegisterServiceMethodHandler<T extends Callback_t>(msg: EMsg_t, callback: T): ServiceRegistrar<T>;
+    RegisterServiceMethodHandlerAction<T extends Callback_t>(msg: EMsg_t, callback: T): ServiceRegistrar<T>;
+    RegisterServiceNotificationHandler<T extends Callback_t>(msg: EMsg_t, callback: T): ServiceRegistrar<T>;
+    RegisterServiceNotificationHandlerAction<T extends Callback_t>(msg: EMsg_t, callback: T): ServiceRegistrar<T>;
+}
+interface CMInterfaceCallbacks {
+    m_ClientConnectionCallbacks: CCallbackList;
+    m_bRunOnce: boolean;
+    m_mapServerTypeCallbacks: Map<number, CCallbackList>;
+    AddCallback(callback: () => void, t?: number): Unsubscribable;
+    RunAllCallbacks(e: number[], ...args: any[]): void;
+    RunCallbacks(e: number | undefined, ...args: any[]): void;
+}
+export interface CMInterface {
+    ClientServersAvailableHandler: ServiceRegistrar<any>;
+    m_ServiceTransport: ServiceTransport;
+    m_bCompletedInitialConnect: boolean;
+    m_bConnected: boolean;
+    m_bConnectionFailed: boolean;
+    m_bForceDisconnect: boolean;
+    m_bLoggedOn: boolean;
+    m_bPerformedInitialClockAdjustment: boolean;
+    m_bShouldChangePersonaStatusOnDisconnect: boolean;
+    m_callbacksOnConnect: CMInterfaceCallbacks;
+    m_callbacksOnConnectOneTime: CMInterfaceCallbacks;
+    m_callbacksOnDisconnect: CMInterfaceCallbacks;
+    m_hEMsgRegistrationObserver: () => void;
+    m_hSharedConnection: number;
+    m_messageHandlers: MessageHandlers;
+    m_nPerfClockServerMSOffset: number;
+    m_nWallClockDriftMS: number;
+    m_onConnect: Promise<void> | undefined;
+    m_rtReconnectThrottleExpiration: number;
+    m_rtReconnectThrottleStart: number;
+    m_setConnectedServers: Set<number>;
+    m_setEMsgHandlers: Set<EMsg_t>;
+    m_setServiceMethodHandlers: Set<string>;
+    m_steamid: CSteamID;
+    m_strIPCountry: string;
+    m_strPersonaName: string;
+    m_unAccountFlags: number;
+    ClearHeartbeatInterval(): void;
+    Connect(): Promise<void>;
+    Disconnect(): void;
+    ResetHeartbeatInterval(): void;
+    SendHeartbeat(): void;
+    SendInternal(msg: CBaseProtoBufMsg): boolean;
+    SendMsgAndAwaitResponse(param0: CBaseProtoBufMsg, param1: EMsg_t): CBaseProtoBufMsg;
+}
+export {};

package/dist/globals/shared/enums.d.ts

@@ -0,0 +1,80 @@
+export declare enum EBrowserType {
+    OffScreen = 0,
+    OpenVROverlay = 1,
+    OpenVROverlay_Dashboard = 2,
+    DirectHWND = 3,
+    DirectHWND_Borderless = 4,
+    DirectHWND_Hidden = 5,
+    ChildHWNDNative = 6,
+    Offscreen_SteamUI = 12,
+    OpenVROverlay_Subview = 13
+}
+export declare enum EPopupCreationFlags {
+    None = 0,
+    Minimized = 1,
+    Hidden = 2,
+    TooltipHint = 4,
+    NoTaskbarIcon = 8,
+    Resizable = 16,
+    ScalePosition = 32,
+    ScaleSize = 64,
+    Maximized = 128,
+    Composited = 256,
+    NotFocusable = 512,
+    FullScreen = 1024,
+    Fullscreen_Exclusive = 2048,
+    ApplyBrowserScaleToDimensions = 4096,
+    AlwaysOnTop = 8192,
+    NoWindowShadow = 16384,
+    NoMinimize = 32768,
+    PopUpMenuHint = 65536,
+    IgnoreSavedSize = 131072,
+    NoRoundedCorners = 262144,
+    ForceRoundedCorners = 524288,
+    OverrideRedirect = 1048576,
+    IgnoreSteamDisplayScale = 2097152,
+    TransparentParentWindow = 4194304,
+    DisableDPIScale = 8388608,
+    ForceBrowserVisible = 16777216
+}
+export declare enum ESteamRealm {
+    Unknown = 0,
+    Global = 1,
+    China = 2
+}
+export declare enum ESteamUISound {
+    LaunchGame = 0,
+    FriendMessage = 1,
+    ChatMention = 2,
+    ChatMessage = 3,
+    ToastMessage = 4,
+    ToastAchievement = 5,
+    ToastMisc = 6,
+    ToastMiscShort = 7,
+    FriendOnline = 8,
+    FriendInGame = 9,
+    VolSound = 10,
+    ShowModal = 11,
+    HideModal = 12,
+    IntoGameDetail = 13,
+    OutOfGameDetail = 14,
+    PagedNavigation = 15,
+    ToggleOn = 16,
+    ToggleOff = 17,
+    SliderUp = 18,
+    SliderDown = 19,
+    ChangeTabs = 20,
+    DefaultOk = 21,
+    OpenSideMenu = 22,
+    CloseSideMenu = 23,
+    BasicNav = 24,
+    FailedNav = 25,
+    Typing = 26,
+    TimerExpired = 27,
+    Screenshot = 28
+}
+export declare enum EUIMode {
+    Unknown = -1,
+    GamePad = 4,
+    Desktop = 7
+}

package/dist/globals/shared/enums.js

@@ -0,0 +1,85 @@
+export var EBrowserType;
+(function (EBrowserType) {
+    EBrowserType[EBrowserType["OffScreen"] = 0] = "OffScreen";
+    EBrowserType[EBrowserType["OpenVROverlay"] = 1] = "OpenVROverlay";
+    EBrowserType[EBrowserType["OpenVROverlay_Dashboard"] = 2] = "OpenVROverlay_Dashboard";
+    EBrowserType[EBrowserType["DirectHWND"] = 3] = "DirectHWND";
+    EBrowserType[EBrowserType["DirectHWND_Borderless"] = 4] = "DirectHWND_Borderless";
+    EBrowserType[EBrowserType["DirectHWND_Hidden"] = 5] = "DirectHWND_Hidden";
+    EBrowserType[EBrowserType["ChildHWNDNative"] = 6] = "ChildHWNDNative";
+    EBrowserType[EBrowserType["Offscreen_SteamUI"] = 12] = "Offscreen_SteamUI";
+    EBrowserType[EBrowserType["OpenVROverlay_Subview"] = 13] = "OpenVROverlay_Subview";
+})(EBrowserType || (EBrowserType = {}));
+export var EPopupCreationFlags;
+(function (EPopupCreationFlags) {
+    EPopupCreationFlags[EPopupCreationFlags["None"] = 0] = "None";
+    EPopupCreationFlags[EPopupCreationFlags["Minimized"] = 1] = "Minimized";
+    EPopupCreationFlags[EPopupCreationFlags["Hidden"] = 2] = "Hidden";
+    EPopupCreationFlags[EPopupCreationFlags["TooltipHint"] = 4] = "TooltipHint";
+    EPopupCreationFlags[EPopupCreationFlags["NoTaskbarIcon"] = 8] = "NoTaskbarIcon";
+    EPopupCreationFlags[EPopupCreationFlags["Resizable"] = 16] = "Resizable";
+    EPopupCreationFlags[EPopupCreationFlags["ScalePosition"] = 32] = "ScalePosition";
+    EPopupCreationFlags[EPopupCreationFlags["ScaleSize"] = 64] = "ScaleSize";
+    EPopupCreationFlags[EPopupCreationFlags["Maximized"] = 128] = "Maximized";
+    EPopupCreationFlags[EPopupCreationFlags["Composited"] = 256] = "Composited";
+    EPopupCreationFlags[EPopupCreationFlags["NotFocusable"] = 512] = "NotFocusable";
+    EPopupCreationFlags[EPopupCreationFlags["FullScreen"] = 1024] = "FullScreen";
+    EPopupCreationFlags[EPopupCreationFlags["Fullscreen_Exclusive"] = 2048] = "Fullscreen_Exclusive";
+    EPopupCreationFlags[EPopupCreationFlags["ApplyBrowserScaleToDimensions"] = 4096] = "ApplyBrowserScaleToDimensions";
+    EPopupCreationFlags[EPopupCreationFlags["AlwaysOnTop"] = 8192] = "AlwaysOnTop";
+    EPopupCreationFlags[EPopupCreationFlags["NoWindowShadow"] = 16384] = "NoWindowShadow";
+    EPopupCreationFlags[EPopupCreationFlags["NoMinimize"] = 32768] = "NoMinimize";
+    EPopupCreationFlags[EPopupCreationFlags["PopUpMenuHint"] = 65536] = "PopUpMenuHint";
+    EPopupCreationFlags[EPopupCreationFlags["IgnoreSavedSize"] = 131072] = "IgnoreSavedSize";
+    EPopupCreationFlags[EPopupCreationFlags["NoRoundedCorners"] = 262144] = "NoRoundedCorners";
+    EPopupCreationFlags[EPopupCreationFlags["ForceRoundedCorners"] = 524288] = "ForceRoundedCorners";
+    EPopupCreationFlags[EPopupCreationFlags["OverrideRedirect"] = 1048576] = "OverrideRedirect";
+    EPopupCreationFlags[EPopupCreationFlags["IgnoreSteamDisplayScale"] = 2097152] = "IgnoreSteamDisplayScale";
+    EPopupCreationFlags[EPopupCreationFlags["TransparentParentWindow"] = 4194304] = "TransparentParentWindow";
+    EPopupCreationFlags[EPopupCreationFlags["DisableDPIScale"] = 8388608] = "DisableDPIScale";
+    EPopupCreationFlags[EPopupCreationFlags["ForceBrowserVisible"] = 16777216] = "ForceBrowserVisible";
+})(EPopupCreationFlags || (EPopupCreationFlags = {}));
+export var ESteamRealm;
+(function (ESteamRealm) {
+    ESteamRealm[ESteamRealm["Unknown"] = 0] = "Unknown";
+    ESteamRealm[ESteamRealm["Global"] = 1] = "Global";
+    ESteamRealm[ESteamRealm["China"] = 2] = "China";
+})(ESteamRealm || (ESteamRealm = {}));
+export var ESteamUISound;
+(function (ESteamUISound) {
+    ESteamUISound[ESteamUISound["LaunchGame"] = 0] = "LaunchGame";
+    ESteamUISound[ESteamUISound["FriendMessage"] = 1] = "FriendMessage";
+    ESteamUISound[ESteamUISound["ChatMention"] = 2] = "ChatMention";
+    ESteamUISound[ESteamUISound["ChatMessage"] = 3] = "ChatMessage";
+    ESteamUISound[ESteamUISound["ToastMessage"] = 4] = "ToastMessage";
+    ESteamUISound[ESteamUISound["ToastAchievement"] = 5] = "ToastAchievement";
+    ESteamUISound[ESteamUISound["ToastMisc"] = 6] = "ToastMisc";
+    ESteamUISound[ESteamUISound["ToastMiscShort"] = 7] = "ToastMiscShort";
+    ESteamUISound[ESteamUISound["FriendOnline"] = 8] = "FriendOnline";
+    ESteamUISound[ESteamUISound["FriendInGame"] = 9] = "FriendInGame";
+    ESteamUISound[ESteamUISound["VolSound"] = 10] = "VolSound";
+    ESteamUISound[ESteamUISound["ShowModal"] = 11] = "ShowModal";
+    ESteamUISound[ESteamUISound["HideModal"] = 12] = "HideModal";
+    ESteamUISound[ESteamUISound["IntoGameDetail"] = 13] = "IntoGameDetail";
+    ESteamUISound[ESteamUISound["OutOfGameDetail"] = 14] = "OutOfGameDetail";
+    ESteamUISound[ESteamUISound["PagedNavigation"] = 15] = "PagedNavigation";
+    ESteamUISound[ESteamUISound["ToggleOn"] = 16] = "ToggleOn";
+    ESteamUISound[ESteamUISound["ToggleOff"] = 17] = "ToggleOff";
+    ESteamUISound[ESteamUISound["SliderUp"] = 18] = "SliderUp";
+    ESteamUISound[ESteamUISound["SliderDown"] = 19] = "SliderDown";
+    ESteamUISound[ESteamUISound["ChangeTabs"] = 20] = "ChangeTabs";
+    ESteamUISound[ESteamUISound["DefaultOk"] = 21] = "DefaultOk";
+    ESteamUISound[ESteamUISound["OpenSideMenu"] = 22] = "OpenSideMenu";
+    ESteamUISound[ESteamUISound["CloseSideMenu"] = 23] = "CloseSideMenu";
+    ESteamUISound[ESteamUISound["BasicNav"] = 24] = "BasicNav";
+    ESteamUISound[ESteamUISound["FailedNav"] = 25] = "FailedNav";
+    ESteamUISound[ESteamUISound["Typing"] = 26] = "Typing";
+    ESteamUISound[ESteamUISound["TimerExpired"] = 27] = "TimerExpired";
+    ESteamUISound[ESteamUISound["Screenshot"] = 28] = "Screenshot";
+})(ESteamUISound || (ESteamUISound = {}));
+export var EUIMode;
+(function (EUIMode) {
+    EUIMode[EUIMode["Unknown"] = -1] = "Unknown";
+    EUIMode[EUIMode["GamePad"] = 4] = "GamePad";
+    EUIMode[EUIMode["Desktop"] = 7] = "Desktop";
+})(EUIMode || (EUIMode = {}));

package/dist/globals/shared/history.d.ts

@@ -0,0 +1,12 @@
+export declare enum Action {
+    Pop = "POP",
+    Push = "PUSH",
+    Replace = "REPLACE"
+}
+export interface Location<S extends object> {
+    key: string;
+    pathname: string;
+    search: string;
+    state: S;
+    hash: string;
+}

package/dist/globals/shared/history.js

@@ -0,0 +1 @@
+export {};

package/dist/globals/shared/index.d.ts

@@ -0,0 +1,5 @@
+export * from './cm';
+export * from './enums';
+export * from './interfaces';
+export * from './navigation';
+export * from './steamid';

package/dist/globals/shared/index.js

@@ -0,0 +1,5 @@
+export * from './cm';
+export * from './enums';
+export * from './interfaces';
+export * from './navigation';
+export * from './steamid';

package/dist/globals/shared/interfaces.d.ts

@@ -0,0 +1,54 @@
+import type { EResult } from '../steam-client/shared';
+import type { EMsg_t } from './cm';
+import type { EBrowserType, EUIMode } from './enums';
+export interface BrowserContext {
+    m_eBrowserType?: EBrowserType;
+    m_eUIMode: EUIMode;
+    m_gameID?: string;
+    m_nBrowserID: number;
+    m_unAppID?: number;
+    m_unPID: number;
+}
+export interface Unsubscribable {
+    Unregister(): void;
+}
+export interface CBaseProtoBufMsg<T = any> {
+    BIsValid(): boolean;
+    Body(): T;
+    BSuccess(): boolean;
+    GetEMsg(): EMsg_t;
+    GetEResult(): EResult;
+    GetErrorMessage(): string;
+}
+export interface CCallbackList<T extends any[] = never> {
+    m_vecCallbacks: ((...args: [...T]) => void)[];
+    ClearAllCallbacks(): void;
+    CountRegistered(): number;
+    Dispatch(...args: [...T]): void;
+    Register(callback: (...args: [...T]) => void): Unsubscribable;
+}
+export interface SubscribableValue<T> {
+    m_callbacks: CCallbackList<[T]>;
+    m_currentValue: T;
+    m_fnEquals?: (currentValue: T, newValue: T) => boolean;
+    Set(value: T): void;
+    Subscribe(subscriber: (value: T) => void): Unsubscribable;
+    get SubscriberCount(): number;
+    get Value(): T;
+}
+export interface MappedSubscribableValue<T> {
+    m_bMappedValueStale: boolean;
+    m_fnMap: (value: T) => T;
+    m_originalSubscribableValue: SubscribableValue<T>;
+    m_mappedSubscribableValue: SubscribableValue<T>;
+    Subscribe(subscriber: (value: T) => void): Unsubscribable;
+    UpdateMappedValue(): void;
+    get Value(): T;
+}
+export interface CScheduledFunc {
+    m_fnCallback: () => void;
+    m_schTimer: number;
+    Cancel(): void;
+    IsScheduled(): boolean;
+    Schedule(timeout: number, fn: () => void): void;
+}

package/dist/globals/shared/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/globals/shared/navigation.d.ts

@@ -0,0 +1,14 @@
+export declare enum ENavigationSourceType {
+    UNKNOWN = 0,
+    GAMEPAD = 1,
+    KEYBOARD_SIMULATOR = 2,
+    MOUSE = 3,
+    TOUCH = 4,
+    LPAD = 5,
+    RPAD = 6
+}
+export interface NavigationSource {
+    eActivationSourceType: ENavigationSourceType;
+    nActiveGamepadIndex: number;
+    nLastActiveGamepadIndex: number;
+}

package/dist/globals/shared/navigation.js

@@ -0,0 +1,10 @@
+export var ENavigationSourceType;
+(function (ENavigationSourceType) {
+    ENavigationSourceType[ENavigationSourceType["UNKNOWN"] = 0] = "UNKNOWN";
+    ENavigationSourceType[ENavigationSourceType["GAMEPAD"] = 1] = "GAMEPAD";
+    ENavigationSourceType[ENavigationSourceType["KEYBOARD_SIMULATOR"] = 2] = "KEYBOARD_SIMULATOR";
+    ENavigationSourceType[ENavigationSourceType["MOUSE"] = 3] = "MOUSE";
+    ENavigationSourceType[ENavigationSourceType["TOUCH"] = 4] = "TOUCH";
+    ENavigationSourceType[ENavigationSourceType["LPAD"] = 5] = "LPAD";
+    ENavigationSourceType[ENavigationSourceType["RPAD"] = 6] = "RPAD";
+})(ENavigationSourceType || (ENavigationSourceType = {}));

package/dist/globals/shared/steamid.d.ts

@@ -0,0 +1,36 @@
+import type { ESteamRealm } from './enums';
+export declare enum EAccountType {
+    Invalid = 0,
+    Individual = 1,
+    Multiseat = 2,
+    GameServer = 3,
+    AnonGameServer = 4,
+    Pending = 5,
+    ContentServer = 6,
+    Clan = 7,
+    Chat = 8,
+    ConsoleUser = 9,
+    AnonUser = 10,
+    Max = 11
+}
+export interface CSteamID {
+    m_ulSteamID: {
+        high: number;
+        low: number;
+        unsigned: boolean;
+    };
+    BIsClanAccount(): boolean;
+    BIsIndividualAccount(): boolean;
+    BIsValid(): boolean;
+    ConvertTo64BitString(): string;
+    GetAccountID(): number;
+    GetAccountType(): EAccountType;
+    GetInstance(): number;
+    GetUniverse(): ESteamRealm;
+    Render(): string;
+    SetAccountID(value: number): void;
+    SetAccountType(value: number): void;
+    SetFromComponents(accountId: number, instance: number, accountType: EAccountType, universe: ESteamRealm): void;
+    SetInstance(value: number): void;
+    SetUniverse(value: ESteamRealm): void;
+}

package/dist/globals/shared/steamid.js

@@ -0,0 +1,15 @@
+export var EAccountType;
+(function (EAccountType) {
+    EAccountType[EAccountType["Invalid"] = 0] = "Invalid";
+    EAccountType[EAccountType["Individual"] = 1] = "Individual";
+    EAccountType[EAccountType["Multiseat"] = 2] = "Multiseat";
+    EAccountType[EAccountType["GameServer"] = 3] = "GameServer";
+    EAccountType[EAccountType["AnonGameServer"] = 4] = "AnonGameServer";
+    EAccountType[EAccountType["Pending"] = 5] = "Pending";
+    EAccountType[EAccountType["ContentServer"] = 6] = "ContentServer";
+    EAccountType[EAccountType["Clan"] = 7] = "Clan";
+    EAccountType[EAccountType["Chat"] = 8] = "Chat";
+    EAccountType[EAccountType["ConsoleUser"] = 9] = "ConsoleUser";
+    EAccountType[EAccountType["AnonUser"] = 10] = "AnonUser";
+    EAccountType[EAccountType["Max"] = 11] = "Max";
+})(EAccountType || (EAccountType = {}));

package/dist/globals/shared/storage.d.ts

@@ -0,0 +1,27 @@
+export declare enum EUserConfigStoreNamespace {
+    Invalid = 0,
+    Library = 1
+}
+export declare enum EConflictResolutionMethod {
+    LastWriteWins = "last-write",
+    CustomMethod = "custom",
+    InitializationOnly = "initial"
+}
+export declare class CUserLocalStorage {
+    GetObject<T extends object>(key: string): Promise<T | null>;
+    GetString(key: string): Promise<string | null>;
+    RemoveObject(key: string, resolutionMethod: EConflictResolutionMethod, resolutionMethodId?: string): Promise<void>;
+    StoreObject<T extends object>(key: string, value: T, resolutionMethod?: EConflictResolutionMethod, resolutionMethodId?: string): Promise<void>;
+}
+export declare class CCloudStorage extends CUserLocalStorage {
+    m_eNamespace: EUserConfigStoreNamespace;
+    Get(key: string): string | null;
+    GetByPrefix(prefix: string): Map<string, string>;
+    GetMapForPrefix(prefix: string): CCloudStorageMap;
+    StoreString(key: string, value: string, resolutionMethod?: EConflictResolutionMethod, resolutionMethodId?: string): Promise<void>;
+}
+export interface CCloudStorageMap extends Map<string, string>, Pick<CCloudStorage, 'GetObject' | 'StoreObject' | 'StoreString'> {
+    m_cloudStorage: CCloudStorage;
+    m_strKeyPrefix: string;
+    get mapInternal(): Map<string, string>;
+}

package/dist/globals/shared/storage.js

@@ -0,0 +1,11 @@
+export var EUserConfigStoreNamespace;
+(function (EUserConfigStoreNamespace) {
+    EUserConfigStoreNamespace[EUserConfigStoreNamespace["Invalid"] = 0] = "Invalid";
+    EUserConfigStoreNamespace[EUserConfigStoreNamespace["Library"] = 1] = "Library";
+})(EUserConfigStoreNamespace || (EUserConfigStoreNamespace = {}));
+export var EConflictResolutionMethod;
+(function (EConflictResolutionMethod) {
+    EConflictResolutionMethod["LastWriteWins"] = "last-write";
+    EConflictResolutionMethod["CustomMethod"] = "custom";
+    EConflictResolutionMethod["InitializationOnly"] = "initial";
+})(EConflictResolutionMethod || (EConflictResolutionMethod = {}));

package/dist/globals/steam-client/App.d.ts

@@ -493,7 +493,7 @@ export interface Badge {
     strName: string;
     strNextLevelName: string;
 }
-interface AppDescription {
+export interface AppDescription {
     strFullDescription: string;
     strSnippet: string;
 }

package/dist/globals/steam-client/Auth.d.ts

@@ -16,7 +16,7 @@ export interface Auth {
     ValidateCachedSignInPin(accountName: string, pin: string): Promise<boolean>;
 }
 export interface AuthRefreshInfo {
-    reason: number;
+    reason: EResult;
     account_name: string;
     login_id_token: string;
 }

package/dist/globals/steam-client/ClientNotifications.d.ts

@@ -1,4 +1,4 @@
-import { BrowserContext } from "./shared";
+import { BrowserContext } from '../shared/interfaces';
 export interface ClientNotifications {
     DisplayClientNotification(notification: EClientUINotificationType, options: string, callback: (context: BrowserContext) => void): void;
     OnRespondToClientNotification(notificationId: number, handleAction: boolean): void;

package/dist/globals/steam-client/Overlay.d.ts

@@ -1,4 +1,5 @@
-import type { EBrowserType, ESteamRealm, EUIComposition, EUIMode, Unregisterable } from "./shared";
+import type { EBrowserType, ESteamRealm, EUIMode } from '../shared/enums';
+import type { EUIComposition, Unregisterable } from './shared';
 export interface Overlay {
     DestroyGamePadUIDesktopConfiguratorWindow(): void;
     GetOverlayBrowserInfo(): Promise<OverlayBrowserInfo[]>;