@decky/ui 4.15.0 → 4.16.0

package/dist/globals/stores/popupmanager.d.ts

@@ -0,0 +1,128 @@
+import type { EBrowserType } from '../shared/enums';
+import type { BrowserContext, CCallbackList, Unsubscribable } from '../shared/interfaces';
+import type { EWindowBringToFront } from '../steam-client/Window';
+export type PopupCallback_t = (popup?: SteamPopup) => void;
+export interface RestoreDetails {
+    bExpires: boolean;
+    last_used: number;
+    strRestoreDetails: string;
+}
+export interface PopupCreationOptions {
+    bCreateHidden?: boolean;
+    bModal?: boolean;
+    title?: string;
+}
+export interface SteamPopupParameters extends PopupCreationOptions {
+    availscreenheight: number;
+    availscreenwidth: number;
+    bHideOnClose: boolean;
+    bNoFocusOnShow: boolean;
+    bNoInitialShow: boolean;
+    bPinned: boolean;
+    body_class: string;
+    browserType: EBrowserType;
+    center_on_window: Window;
+    dimensions: {
+        height?: number;
+        left?: number;
+        top?: number;
+        width?: number;
+    };
+    eCreationFlags: number;
+    html_class: string;
+    hwndParent: number;
+    minHeight: number;
+    minWidth: number;
+    parent_container_popup_id: number;
+    popup_class: string;
+    replace_existing_popup: boolean;
+    strRestoreDetails: string;
+    strUserAgent: string;
+    strVROverlayKey: string;
+    target_browser: BrowserContext;
+    m_strName: string;
+    m_strTitle: string;
+    window_opener_id: number;
+}
+export interface CRenderWhenLinksReady {
+    m_fnRender: () => void;
+    m_rgLoadingLinks: Node[];
+    AddLink(link: Node, checkIfLoaded: boolean): void;
+    SetTarget(renderCallback: () => void): void;
+}
+export interface SteamPopup {
+    m_bCreateHidden: boolean;
+    m_bCreated: boolean;
+    m_bFocused: boolean;
+    m_callbacks: {
+        onLoad(e: any, t: any): any;
+        onResize(t: any, r: any, i: any): any;
+        updateParamsBeforeShow(...args: any[]): any;
+    };
+    m_element: HTMLElement;
+    m_fnReadyToRender(...args: any[]): any;
+    m_onCreateRender: any;
+    m_popup: Window;
+    m_renderWhenReady: CRenderWhenLinksReady;
+    m_rgParams: Partial<SteamPopupParameters>;
+    m_strName: string;
+    m_strTitle: string;
+    BIsClosed(): boolean;
+    BIsFocused(): boolean;
+    BIsValid(): boolean;
+    BIsVisible(): boolean;
+    Close(): void;
+    Focus(eForceOS?: EWindowBringToFront): void;
+    GetName(): string;
+    GetWindowRestoreDetails(): Promise<string>;
+    IsMaximized(): Promise<boolean>;
+    IsMinimized(): Promise<boolean>;
+    OnBlur(): void;
+    OnCreate(): void;
+    OnDragOver(ev: DragEvent): void;
+    OnDrop(ev: DragEvent): void;
+    OnFocus(): void;
+    OnMessage<T = any>(ev: MessageEvent<T>): void;
+    OnResize(): void;
+    OnResizeEvent(): void;
+    OnUnload(ev?: Event): void;
+    ReleasePopup(): void;
+    RemoveEventListeners(): void;
+    Render(wnd: Window, element: HTMLElement): void;
+    Show(eForceOS?: EWindowBringToFront): void;
+    UpdateParamsBeforeShow<T = Partial<SteamPopupParameters>>(params: T): T;
+}
+export interface CPopupManager {
+    DebouncedSaveSavedDimensionStore_DebounceProperties: {
+        hTimer: number;
+        nPending: number;
+    };
+    m_DynamicCSSObserver: MutationObserver;
+    m_bSaveRequired: boolean;
+    m_bShuttingDown: boolean;
+    m_mapPopups: Map<string, SteamPopup>;
+    m_mapRestoreDetails: Map<string, RestoreDetails>;
+    m_rgPopupCreatedCallbacks: CCallbackList<[PopupCallback_t]>;
+    m_rgPopupDestroyedCallbacks: CCallbackList<[PopupCallback_t]>;
+    m_rgShutdownCallbacks: (() => void)[];
+    m_unCurrentAccountID: number;
+    AddPopupCreatedCallback(callback: PopupCallback_t): Unsubscribable;
+    AddPopupDestroyedCallback(callback: PopupCallback_t): Unsubscribable;
+    AddShutdownCallback(callback: () => void): Unsubscribable;
+    AddTrackedPopup(popup: SteamPopup): void;
+    BAnyMenuHasFocus(): boolean;
+    BAnyPopupHasFocus(): boolean;
+    BShuttingDown(): boolean;
+    ClearSavedDimensionStore(): void;
+    ClosePopupsOwnedByBrowser(browser: BrowserContext): void;
+    GetExistingPopup(popupName: string): SteamPopup;
+    GetLocalStorageKey(): string;
+    GetPopupForWindow(window: Window): SteamPopup;
+    GetPopups(): SteamPopup[];
+    GetRestoreDetails(windowName: string): string;
+    LoadSavedDimensionStore(): void;
+    RemoveTrackedPopup(popup: SteamPopup): void;
+    SaveSavedDimensionStore(): void;
+    SetCurrentLoggedInAccountID(accountId: number): void;
+    SetRestoreDetails(popupName: string, restoreDetails: string, expires: boolean): void;
+}

package/dist/globals/stores/popupmanager.js

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

package/dist/globals/stores/securitystore.d.ts

@@ -0,0 +1,35 @@
+interface LockScreenSettings_t {
+    version: number;
+    bLockOnWake: boolean;
+    bLockOnLogin: boolean;
+    bLockDesktopMode: boolean;
+    strPIN: string;
+    strOwnerAccountName: string;
+    bUserForgotPin: boolean;
+    bShowResetPinModal: boolean;
+}
+interface ActiveLockScreenProps_t {
+    allowAnyPIN?: boolean;
+    closeModal?: () => void;
+    hideForgotPIN?: boolean;
+    preventCancel?: boolean;
+    preventSteamButtons?: boolean;
+    onSuccess?: () => void;
+}
+export declare class CSecurityStore {
+    BConsumeLockTocket(): boolean;
+    BResettingPIN(): boolean;
+    BShowResetPINModal(): boolean;
+    BeginPINReset(): Promise<void>;
+    ClearPIN(bShowResetPinModal: boolean): void;
+    ClearPINIfNotUsed(): void;
+    GetActiveLockScreenProps(): ActiveLockScreenProps_t | null;
+    GetSettings(): LockScreenSettings_t;
+    InitialLoginComplete(accountName: string): void;
+    IsLockScreenActive(): boolean;
+    ProvideLockTicket(value: boolean): void;
+    SetActiveLockScreenProps(props: ActiveLockScreenProps_t | null): void;
+    SetHasShownResetPINModal(): void;
+    SetSettings(settings: LockScreenSettings_t): void;
+}
+export {};

package/dist/globals/stores/securitystore.js

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

package/dist/globals/stores/settingsstore.d.ts

@@ -0,0 +1,86 @@
+import type { CMInterface } from '../shared/cm';
+import type { SubscribableValue } from '../shared/interfaces';
+import type { CUserLocalStorage } from '../shared/storage';
+import type { FriendSettingsChange } from '../steam-client/FriendSettings';
+import type { EClientNotificationType } from '../steam-client/Notifications';
+import type { MsgClientSettings, MsgMonitorInfo, SteamSettings } from '../steam-client/Settings';
+export declare enum ETextFilterSetting {
+    SteamLabOptedOut = 0,
+    Enabled = 1,
+    EnabledAllowProfanity = 2,
+    Disabled = 3
+}
+export declare enum EUserReviewScorePreference {
+    Unset = 0,
+    IncludeAll = 1,
+    ExcludeBombs = 2
+}
+export declare enum EProvideDeckFeedbackPreference {
+    Unset = 0,
+    Yes = 1,
+    No = 2
+}
+interface SteamNotificationPreference {
+    notification_targets: number;
+    notification_type: EClientNotificationType;
+}
+interface ContentDescriptor {
+    content_descriptorid: number;
+    timestamp_added: number;
+}
+interface UserContentDescriptorPreferences {
+    content_descriptors_to_exclude: ContentDescriptor[];
+}
+export interface BatteryPreferences {
+    bShowBatteryPercentage: boolean;
+}
+export interface CommunityPreferences {
+    bParenthesizeNicknames: boolean;
+    bTextFilterIgnoreFriends: boolean;
+    content_descriptor_preferences: UserContentDescriptorPreferences & {
+        eTextFilterSetting: ETextFilterSetting;
+    };
+}
+export interface StorePreferences {
+    content_descriptor_preferences: UserContentDescriptorPreferences;
+    eReviewScorePreference: EUserReviewScorePreference;
+    provide_deck_feedback: EProvideDeckFeedbackPreference;
+}
+export interface CSettingsStore {
+    m_BatteryPreferences: SubscribableValue<BatteryPreferences>;
+    m_CMInterface: CMInterface;
+    m_ClientSettings: MsgClientSettings;
+    m_CommunityPreferences: CommunityPreferences;
+    m_FriendSettings: FriendSettingsChange;
+    m_MonitorInfo: MsgMonitorInfo | undefined;
+    m_NotificationSettings: SteamNotificationPreference[];
+    m_Settings: SteamSettings;
+    m_StorePreferences: StorePreferences;
+    m_bSteamIsInTournamentMode: boolean;
+    m_bWindowed: boolean;
+    m_localStorage: CUserLocalStorage;
+    m_setDeferredSettings: Set<string>;
+    m_strTimeZoneID: SubscribableValue<string>;
+    BIsConnectedToSteam(): boolean;
+    CommunityPreferencesToMessage(value: CommunityPreferences): any;
+    GetBatteryPreferences(): BatteryPreferences;
+    GetClientSetting<K extends keyof MsgClientSettings, V = ReturnType<MsgClientSettings[K]>>(setting: K): [V, (value: V) => void];
+    IsDeferred(value: string): boolean;
+    IsSteamInTournamentMode(): boolean;
+    MergeCommunityPreferences(e: any, t: any): void;
+    MergeNotificationPreferences(e: any): void;
+    MergeStorePreferences(e: any, t: any): void;
+    RefreshMonitorInfo(): void;
+    SetBatteryPreferences(value: BatteryPreferences): void;
+    SetCommunityPreferences(value: CommunityPreferences): void;
+    SetDeferred(value: string): void;
+    SetStorePreferences(value: StorePreferences): void;
+    SetWindowedMode(value: boolean): void;
+    ToggleNotificationPreference(e: any, t: any): void;
+    UpdateCommunityPreference(e: any, t: any): any;
+    UpdateCommunityPreferences(e: any): any;
+    UpdateFriendSetting(e: any, t: any): any;
+    UpdateFriendSettings(e: any): any;
+    UpdateUserConfigObject(): void;
+}
+export {};

package/dist/globals/stores/settingsstore.js

@@ -0,0 +1,19 @@
+export var ETextFilterSetting;
+(function (ETextFilterSetting) {
+    ETextFilterSetting[ETextFilterSetting["SteamLabOptedOut"] = 0] = "SteamLabOptedOut";
+    ETextFilterSetting[ETextFilterSetting["Enabled"] = 1] = "Enabled";
+    ETextFilterSetting[ETextFilterSetting["EnabledAllowProfanity"] = 2] = "EnabledAllowProfanity";
+    ETextFilterSetting[ETextFilterSetting["Disabled"] = 3] = "Disabled";
+})(ETextFilterSetting || (ETextFilterSetting = {}));
+export var EUserReviewScorePreference;
+(function (EUserReviewScorePreference) {
+    EUserReviewScorePreference[EUserReviewScorePreference["Unset"] = 0] = "Unset";
+    EUserReviewScorePreference[EUserReviewScorePreference["IncludeAll"] = 1] = "IncludeAll";
+    EUserReviewScorePreference[EUserReviewScorePreference["ExcludeBombs"] = 2] = "ExcludeBombs";
+})(EUserReviewScorePreference || (EUserReviewScorePreference = {}));
+export var EProvideDeckFeedbackPreference;
+(function (EProvideDeckFeedbackPreference) {
+    EProvideDeckFeedbackPreference[EProvideDeckFeedbackPreference["Unset"] = 0] = "Unset";
+    EProvideDeckFeedbackPreference[EProvideDeckFeedbackPreference["Yes"] = 1] = "Yes";
+    EProvideDeckFeedbackPreference[EProvideDeckFeedbackPreference["No"] = 2] = "No";
+})(EProvideDeckFeedbackPreference || (EProvideDeckFeedbackPreference = {}));

package/dist/globals/stores/steamuistore/gamepadbrowserview.d.ts

@@ -0,0 +1,143 @@
+import type { CCallbackList, SubscribableValue } from '../../shared';
+import type { BrowserViewHistory, BrowserViewPopup } from '../../steam-client/browser-view/BrowserViewPopup';
+import type { CFocusNavController } from '../focusnavcontroller';
+declare enum EGameInputSupportLevel {
+    PageUnloading = 0,
+    Unknown = 1,
+    None = 2,
+    Basic = 3,
+    Full = 4
+}
+interface ActionDescription {
+    button: any;
+    descriptions: any;
+    source: any;
+    support: EGameInputSupportLevel;
+}
+interface GamepadBrowserViewMessageDetails_t {
+    type: string;
+    data: {
+        event: string;
+        details: GamepadEvent;
+    };
+}
+declare class CGamepadBrowserViewBridge {
+    m_CallbackOnUnhandledInput: CCallbackList<[GamepadButton]>;
+    m_CallbackUpdateActionDescriptions: CCallbackList<[ActionDescription]>;
+    m_NavigationController: CFocusNavController;
+    m_eGameInputSupportLevel: SubscribableValue<EGameInputSupportLevel>;
+    m_lastActionDescriptions: any;
+    m_postMessage: CGamepadBrowserViewMessageHandler;
+    BClientManagesVirtualKeyboard(): boolean;
+    ForwardGamepadEventDetail(eventType: string, ev: GamepadEventInit): void;
+    GetGameInputSupportLevel(): SubscribableValue<EGameInputSupportLevel>;
+    OnUnhandledInputCallbacks(): CCallbackList<[GamepadButton]>;
+    RegisterOnActionDescriptionsChangedCallback(value: (descriptions: any) => void): () => void;
+    SetGameInputSupportLevel(value: EGameInputSupportLevel, param1: string): void;
+    TakeFocus(): void;
+}
+interface VirtualKeyboardRef_t {
+    ShowVirtualKeyboard(): void;
+    ShowModalKeyboard(): void;
+    SetAsCurrentVirtualKeyboardTarget(): void;
+    HideVirtualKeyboard(msDelay: number): void;
+    DelayHideVirtualKeyboard(msDelay: number): void;
+    BIsActive(): boolean;
+    BIsElementValidForInput(): boolean;
+}
+interface VirtualKeyboardClientMsg_t {
+    message: string;
+    msDelay: number;
+}
+declare class CVirtualKeyboardClient {
+    m_ownerWindow: Window;
+    Init(wnd: Window): () => void;
+    CreateVirtualKeyboardRef(): VirtualKeyboardRef_t;
+    ShowVirtualKeyboard(): void;
+    ShowModalKeyboard(): void;
+    HideVirtualKeyboard(msDelay: number): void;
+    OnBrowserViewMessage(message: string, args: string): void;
+    OnMessage(msg: any): void;
+    InternalDispatchMessage(msg: any): void;
+    SendMessage(msg: VirtualKeyboardClientMsg_t): void;
+}
+declare class CVirtualKeyboardHost {
+    m_showKeyboard: () => void;
+    m_showModalKeyboard: () => void;
+    m_hideKeyboard: () => void;
+    OnMessage(message: string, args: string, _currentURL: string): void;
+}
+declare class CGamepadBrowserViewMessageHandler {
+    m_browser: BrowserViewPopup;
+    m_fnCallback: (parsedArgs: any) => void;
+    OnMessage(message: string, args: string): void;
+    PostMessage(detail: GamepadBrowserViewMessageDetails_t): void;
+    RegisterForMessage(callback: (parsedArgs: any) => void): void;
+}
+export declare class CGamepadBrowserView {
+    m_URL: string;
+    m_URLRequested: string | undefined;
+    m_bCanGoBackward: boolean;
+    m_bCanGoForward: boolean;
+    m_bExternalRequest: boolean;
+    m_bIsDestroying: boolean;
+    m_bLoading: boolean;
+    m_bSeenLoadStartForExternalRequest: boolean;
+    m_bUseVRKeyboard: boolean;
+    m_browserView: BrowserViewPopup;
+    m_fnBeforeCloseHandler: ((bIsDestroying: boolean) => void) | null;
+    m_fnGoBackOverride: (() => void) | undefined;
+    m_gamepadBridge: CGamepadBrowserViewBridge;
+    m_history: BrowserViewHistory;
+    m_loadErrorCode: number | null;
+    m_loadErrorDesc: string | null;
+    m_loadErrorURL: string | null;
+    m_mapMessageCallbacks: Map<string, CCallbackList>;
+    m_onFinishedRequestCallbacks: CCallbackList;
+    m_onStartLoadingCallbacks: CCallbackList;
+    m_onStartRequestCallbacks: CCallbackList;
+    m_refKeyboard: VirtualKeyboardRef_t;
+    m_strInitialURL: string | undefined;
+    m_strName: string;
+    m_strTitle: string;
+    m_strUserAgentIdentifier: string;
+    m_strUserAgentOverride: string;
+    m_strVROverlayKey: string | undefined;
+    m_virtualKeyboardHost: CVirtualKeyboardHost;
+    AddHardwareHeaders(): void;
+    BExternalTriggeredLoad(): boolean;
+    BIsLoadingURL(): boolean;
+    BrowserViewOnMessage(message: string, args: string, currentURL: string): void;
+    Destroy(): void;
+    ForwardGamepadEventDetail(eventType: string, ev: GamepadEventInit): void;
+    GetBrowser(): BrowserViewPopup;
+    GetGameInputSupportLevel(): EGameInputSupportLevel;
+    GetOnMessageCallbacks(msg: string): CCallbackList;
+    GoBack(): void;
+    GoForward(): void;
+    Init(controller: CFocusNavController, keyboard: CVirtualKeyboardClient, parent: EventTarget): void;
+    LoadURL(url: string): void;
+    OnBeforeClose(): void;
+    OnHistoryChanged(): void;
+    OnNodeHasFocus(elementIdOrTagName: string, elementTag: string, inputType: string, token: string, param4: boolean): void;
+    OnUnhandledInputCallbacks(): CCallbackList<[GamepadButton]>;
+    OnVirtualKeyboardPress(keyName: string): void;
+    RegisterOnActionDescriptionsChangedCallback(param0: any): () => void;
+    Reload(): void;
+    SetBeforeCloseHandler(value: (bIsDestroying: boolean) => void): void;
+    SetGoBackOverride(value: () => void): void;
+    get CanGoBackward(): boolean;
+    get CanGoForward(): boolean;
+    get DisplayURL(): boolean;
+    get FinishedRequestCallbacks(): CCallbackList;
+    get History(): BrowserViewHistory;
+    get LoadErrorCode(): number | null;
+    get LoadErrorDescription(): string | null;
+    get LoadErrorURL(): string | null;
+    get StartLoadingCallbacks(): CCallbackList;
+    get StartRequestCallbacks(): CCallbackList;
+    get Title(): string;
+    get URL(): string;
+    get name(): string;
+}
+export {};

package/dist/globals/stores/steamuistore/gamepadbrowserview.js

@@ -0,0 +1,9 @@
+var EGameInputSupportLevel;
+(function (EGameInputSupportLevel) {
+    EGameInputSupportLevel[EGameInputSupportLevel["PageUnloading"] = 0] = "PageUnloading";
+    EGameInputSupportLevel[EGameInputSupportLevel["Unknown"] = 1] = "Unknown";
+    EGameInputSupportLevel[EGameInputSupportLevel["None"] = 2] = "None";
+    EGameInputSupportLevel[EGameInputSupportLevel["Basic"] = 3] = "Basic";
+    EGameInputSupportLevel[EGameInputSupportLevel["Full"] = 4] = "Full";
+})(EGameInputSupportLevel || (EGameInputSupportLevel = {}));
+export {};

package/dist/globals/stores/steamuistore/gamepaduiaudio.d.ts

@@ -0,0 +1,36 @@
+import type { ESteamUISound, EUIMode, SubscribableValue, Unsubscribable } from '../../shared';
+import type { FocusChangeEvent } from '../../steam-client/system/UI';
+import type { CFocusNavigationContext } from '../../stores';
+type NavAudioFile_t = 'bumper_end.wav' | 'camera1.wav' | 'confirmation_negative.wav' | 'confirmation_positive.wav' | 'deck_ui_achievement_toast.wav' | 'deck_ui_bumper_end_02.wav' | 'deck_ui_default_activation.wav' | 'deck_ui_hide_modal.wav' | 'deck_ui_into_game_detail.wav' | 'deck_ui_launch_game.wav' | 'deck_ui_message_toast.wav' | 'deck_ui_misc_01.wav' | 'deck_ui_misc_08.wav' | 'deck_ui_misc_10.wav' | 'deck_ui_navigation.wav' | 'deck_ui_out_of_game_detail.wav' | 'deck_ui_show_modal.wav' | 'deck_ui_side_menu_fly_in.wav' | 'deck_ui_side_menu_fly_out.wav' | 'deck_ui_slider_down.wav' | 'deck_ui_slider_up.wav' | 'deck_ui_switch_toggle_off.wav' | 'deck_ui_switch_toggle_on.wav' | 'deck_ui_tab_transition_01.wav' | 'deck_ui_tile_scroll.wav' | 'deck_ui_toast.wav' | 'deck_ui_typing.wav' | 'deck_ui_volume.wav' | 'desktop_toast_default.wav' | 'desktop_toast_short.wav' | 'pop_sound.wav' | 'recording_highlight.wav' | 'recording_start.wav' | 'recording_stop.wav' | 'steam_at_mention.m4a' | 'steam_chatroom_notification.m4a' | 'timer_expired_alarm.wav' | 'ui_steam_message_old_smooth.m4a' | 'ui_steam_smoother_friend_join.m4a' | 'ui_steam_smoother_friend_online.m4a';
+declare class CGamepadUIAudioPlaybackManager {
+    m_Cancelled: boolean;
+    m_Manager: any;
+    m_RepeatCount: number;
+    m_Source: BaseAudioContext | undefined;
+    m_TimesPlayed: number;
+    m_URL: string;
+    m_cbPlaybackFinished: (() => void) | null;
+    NotifyPlaybackFinished(): void;
+    OnFailure(): void;
+    OnPlaybackEnded(): void;
+    RegisterOnPlaybackFinished(callback: () => void): void;
+    StopPlayback(): void;
+    get url(): string;
+}
+export declare class CGamepadUIAudioStore {
+    m_AudioPlaybackManager: CGamepadUIAudioPlaybackManager;
+    m_bCanPlaySound: boolean;
+    m_currentlyFocusedAppid: SubscribableValue<number>;
+    m_fnGetUIMode: () => EUIMode;
+    m_pendingSoundHandle: number | null;
+    m_pendingSoundType: ESteamUISound;
+    OnFocusChangeEvent(ev: FocusChangeEvent): void;
+    OnGamepadFocusChanged(e: number, t: any, r: any | undefined): void;
+    OnUnhandledButtonDownEvent(ev: GamepadEvent): void;
+    PlayAudioURL(sound: `/sounds/${NavAudioFile_t}`): CGamepadUIAudioPlaybackManager;
+    PlayNavSound(type: ESteamUISound): void;
+    PlayNavSoundInternal(type: ESteamUISound): void;
+    RegisterFocusNavContext(context: CFocusNavigationContext): Unsubscribable;
+    get AudioPlaybackManager(): CGamepadUIAudioPlaybackManager;
+}
+export {};

package/dist/globals/stores/steamuistore/gamepaduiaudio.js

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

package/dist/globals/stores/steamuistore/index.d.ts

@@ -0,0 +1,129 @@
+import type { EUIMode } from '../../shared';
+import type { ENavigationSourceType, NavigationSource } from '../../shared/navigation';
+import type { SteamAppOverview } from '../../steam-client/App';
+import type { ControllerInfo } from '../../steam-client/Input';
+import type { EResult } from '../../steam-client/shared';
+import type { ERefreshLoginReason } from '../../steam-client/UI';
+import type { EShutdownStep } from '../../steam-client/User';
+import type { CFocusNavController } from '../focusnavcontroller';
+import type { CGamepadUIAudioStore } from './gamepaduiaudio';
+import type { CWindowStore, SteamUIWindowInstance } from './window';
+declare enum EAppDetailsDisplayMode {
+    SteamUI = 0,
+    BasicUI = 1
+}
+declare enum ENavigationMode {
+    Digital = 0,
+    Cursor = 1
+}
+export interface CSteamUIStore {
+    m_ConfiguratorWidth: number;
+    m_GamepadNavigationManager: CFocusNavController;
+    m_GamepadUIAudioStore: CGamepadUIAudioStore;
+    m_WindowStore: CWindowStore;
+    m_appDetailsDisplayMode: EAppDetailsDisplayMode;
+    m_bConsoleEnabledByUser: boolean;
+    m_bHomeAndQuickAccessButtonsEnabled: boolean;
+    m_bIsDeckFactoryImage: boolean;
+    m_bPreviouslyNavigatedToRunningApp: boolean;
+    m_bShowingLockScreen: boolean;
+    m_bStreamingRemotePlayTogether: boolean;
+    m_eErrorCondition: ERefreshLoginReason;
+    m_eErrorConditionResult: EResult;
+    m_mainInstanceUIMode: EUIMode;
+    m_nResumeStreamingInputTimeoutHandle: number;
+    m_navigationSource: NavigationSource;
+    m_runningAppIDs: number[];
+    m_shutdownState: {
+        appid: number;
+        bAllowForceQuit: boolean;
+        bFailed: boolean;
+        eShutdownState: EShutdownStep;
+    };
+    m_strStandaloneConfiguratorURL: string | null;
+    m_streamingAppID: number;
+    m_textFilterStore: any;
+    BCanNavigateToRunningApp(): boolean;
+    BControllerIndexValid(index: number): boolean;
+    BHomeAndQuickAccessButtonsEnabled(): boolean;
+    BIsAnyWindowFocused(): boolean;
+    BIsOverlayPath(path: string): boolean;
+    BIsShuttingDown(): boolean;
+    BIsStreamingGame(appid: number): boolean;
+    BIsStreamingRemotePlayTogether(): boolean;
+    BIsStreamingRemotePlayTogetherGame(appid: number): boolean;
+    BIsTransparentBackgroundPath(path: string): boolean;
+    BIsVROverlayApp(overview: SteamAppOverview): boolean;
+    BIsVrOnlyGame(overview: SteamAppOverview): boolean;
+    BRemotePlaySessionLocalClient(steam64Id: string): boolean;
+    CancelRefreshLogin(): void;
+    ClearSaleCache(): Promise<void>;
+    ClearShutdownFailure(): void;
+    CloseSideMenus(): void;
+    DisableHomeAndQuickAccessButtons(): void;
+    EnableHomeAndQuickAccessButtons(): void;
+    ExcludedTitlesForPlatform(): number[];
+    GetFocusedWindowInstance(): SteamUIWindowInstance;
+    GetLastLibraryTab(): {
+        collectionid?: string;
+        strActiveTab: string;
+    };
+    GetShowingLockScreen(): boolean;
+    GetShutdownState(): {
+        appid: number;
+        bAllowForceQuit: boolean;
+        bFailed: boolean;
+        eShutdownState: EShutdownStep;
+    };
+    GetWindowForRunningAppNavigation(): SteamUIWindowInstance;
+    GetWindowInstanceForPID(pid: number): SteamUIWindowInstance | undefined;
+    IsAnyAppRunning(): boolean;
+    IsConsoleEnabled(): boolean;
+    IsDeckFactoryImage(): boolean;
+    IsDesktopUIWindowActive(): boolean;
+    IsGamepadUIWindowActive(): boolean;
+    Navigate(route: string, matchRoute?: boolean, replaceHistoryEntry?: boolean): void;
+    NavigateToLayoutPreview(appid: number, instance?: SteamUIWindowInstance): void;
+    NavigateToRunningApp(e: boolean): void;
+    OpenPowerMenu(parent: HTMLElement, onCancel: () => void): void;
+    PreserveNavigation(): void;
+    ReopenPreModalSideMenu(): void;
+    ResetErrorCondition(): void;
+    RestoreNavigation(): void;
+    ScopeRunningApps(): void;
+    SetConfiguratorWidth(value: number): void;
+    SetConsoleEnabled(): void;
+    SetLastLibraryTab(activeTab: string, collectionId: string): Promise<void>;
+    SetRefreshLogin(): void;
+    SetRunningApp(appid: number): void;
+    SetShowingLockScreen(value: boolean): void;
+    SetStandaloneConfiguratorURL(value: string): void;
+    get ActiveControllerIndex(): number;
+    get ActiveNavigationInfo(): {
+        eMode: ENavigationMode;
+        eSourceType: ENavigationSourceType;
+        nControllerIndex: number;
+    };
+    get ActiveNavigationMode(): ENavigationMode;
+    get ActiveNavigationSourceType(): ENavigationSourceType;
+    get ActiveWindowInstance(): SteamUIWindowInstance;
+    get BIsInOOBE(): boolean;
+    get ConfiguratorWidth(): number;
+    get ErrorCondition(): number;
+    get ErrorConditionResult(): EResult;
+    get ForceBetaSectionVisible(): boolean;
+    get GamepadUIAudio(): CGamepadUIAudioStore;
+    get MainInstanceUIMode(): EUIMode;
+    get MainRunningApp(): SteamAppOverview | undefined;
+    get MainRunningAppID(): number | undefined;
+    get MostRecentlyActiveController(): ControllerInfo;
+    get MostRecentlyActiveControllerIndex(): number;
+    get NavigationManager(): CFocusNavController;
+    get RemainInBigPictureModeOnClose(): boolean;
+    get RunningApps(): SteamAppOverview[];
+    get ShouldZoomStandaloneConfigurator(): boolean;
+    get StandaloneConfiguratorURL(): string | null;
+    get TextFilterStore(): any;
+    get WindowStore(): CWindowStore;
+}
+export {};

package/dist/globals/stores/steamuistore/index.js

@@ -0,0 +1,11 @@
+var EAppDetailsDisplayMode;
+(function (EAppDetailsDisplayMode) {
+    EAppDetailsDisplayMode[EAppDetailsDisplayMode["SteamUI"] = 0] = "SteamUI";
+    EAppDetailsDisplayMode[EAppDetailsDisplayMode["BasicUI"] = 1] = "BasicUI";
+})(EAppDetailsDisplayMode || (EAppDetailsDisplayMode = {}));
+var ENavigationMode;
+(function (ENavigationMode) {
+    ENavigationMode[ENavigationMode["Digital"] = 0] = "Digital";
+    ENavigationMode[ENavigationMode["Cursor"] = 1] = "Cursor";
+})(ENavigationMode || (ENavigationMode = {}));
+export {};

package/dist/globals/stores/steamuistore/menu.d.ts

@@ -0,0 +1,39 @@
+export declare enum EQuickAccessTab {
+    Notifications = 0,
+    RemotePlayTogetherControls = 1,
+    VoiceChat = 2,
+    Friends = 3,
+    Settings = 4,
+    Perf = 5,
+    Help = 6,
+    Soundtrack = 7,
+    VRBatteries = 8,
+    Decky = 999
+}
+export declare enum ESideMenu {
+    None = 0,
+    Main = 1,
+    QuickAccess = 2
+}
+export declare class CMenuStore {
+    m_MainMenuStore: any;
+    m_cSideMenuExtendedVisibilityRequests: number;
+    m_cSuppressRequests: number;
+    m_eLastRequestedSideMenu: ESideMenu;
+    m_eOpenSideMenu: ESideMenu;
+    m_eQuickAccessTab: EQuickAccessTab;
+    ClearLastRequestedSideMenu(): void;
+    CloseSideMenus(): void;
+    GetLastRequestedSideMenu(): ESideMenu;
+    GetOpenSideMenu(): ESideMenu;
+    GetQuickAccessTab(): EQuickAccessTab;
+    IsAnySideMenuVisible(): boolean;
+    IsSideMenuInteractable(): boolean;
+    IsSideMenuVisible(menu: ESideMenu): boolean;
+    OpenSideMenu(menu: ESideMenu): void;
+    OpenQuickAccessMenu(tab?: EQuickAccessTab): void;
+    OpenMainMenu(): void;
+    RequestExtendSideMenuVisibility(): () => void;
+    SetSuppressMenus(): () => void;
+    ToggleSideMenu(menu: ESideMenu): void;
+}

package/dist/globals/stores/steamuistore/menu.js

@@ -0,0 +1,19 @@
+export var EQuickAccessTab;
+(function (EQuickAccessTab) {
+    EQuickAccessTab[EQuickAccessTab["Notifications"] = 0] = "Notifications";
+    EQuickAccessTab[EQuickAccessTab["RemotePlayTogetherControls"] = 1] = "RemotePlayTogetherControls";
+    EQuickAccessTab[EQuickAccessTab["VoiceChat"] = 2] = "VoiceChat";
+    EQuickAccessTab[EQuickAccessTab["Friends"] = 3] = "Friends";
+    EQuickAccessTab[EQuickAccessTab["Settings"] = 4] = "Settings";
+    EQuickAccessTab[EQuickAccessTab["Perf"] = 5] = "Perf";
+    EQuickAccessTab[EQuickAccessTab["Help"] = 6] = "Help";
+    EQuickAccessTab[EQuickAccessTab["Soundtrack"] = 7] = "Soundtrack";
+    EQuickAccessTab[EQuickAccessTab["VRBatteries"] = 8] = "VRBatteries";
+    EQuickAccessTab[EQuickAccessTab["Decky"] = 999] = "Decky";
+})(EQuickAccessTab || (EQuickAccessTab = {}));
+export var ESideMenu;
+(function (ESideMenu) {
+    ESideMenu[ESideMenu["None"] = 0] = "None";
+    ESideMenu[ESideMenu["Main"] = 1] = "Main";
+    ESideMenu[ESideMenu["QuickAccess"] = 2] = "QuickAccess";
+})(ESideMenu || (ESideMenu = {}));