@decky/ui 4.15.1 → 4.16.1

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

@@ -0,0 +1,206 @@
+import type { BrowserContext } from '../../shared';
+import type { BrowserViewCreateOptions } from '../../steam-client/browser-view';
+import type { ENotificationPosition } from '../../steam-client/Overlay';
+import type { EWindowType, SteamWindow } from '../../steam-client/UI';
+import type { ClipSummary_t, PlaybackDefinition_t } from '../gamerecordingstore';
+import type { SteamBrowserHistoryState } from '../mainwindowbrowsermanager';
+import type { CGamepadBrowserView } from './gamepadbrowserview';
+import type { CMenuStore } from './menu';
+export declare enum EOpenSideMenu {
+    None = 0,
+    Main = 1,
+    QuickAccess = 2
+}
+type SettingsSection_t = 'Accessibility' | 'Account' | 'Audio' | 'Bluetooth' | 'Broadcast' | 'Cloud' | 'Compatibility' | 'Controller' | 'Customization' | 'DesktopSecurity' | 'Developer' | 'Display' | 'Downloads' | 'Family' | 'Friends' | 'GameRecording' | 'General' | 'Home' | 'InGame' | 'InGameVoice' | 'Interface' | 'Internal' | 'Internet' | 'Keyboard' | 'Library' | 'Music' | 'Notifications' | 'Power' | 'RemotePlay' | 'Root' | 'Security' | 'Storage' | 'System' | 'Voice';
+interface NavigatorRouterState<T> {
+    state: T;
+}
+interface MediaManagerFilter {
+    listSource: {
+        type: 'app';
+        gameid: string;
+    } | {
+        type: 'clip' | 'recording' | 'screenshot';
+        id?: string;
+        summary?: ClipSummary_t;
+    } | {
+        type: 'phase';
+        phase: any;
+    } | {
+        type: 'recents';
+    };
+    mediaType?: 'all' | 'clip' | 'recording' | 'screenshot';
+    uploadStatus?: 'all' | 'uploaded' | 'notuploaded';
+}
+interface SteamWindowNavigator {
+    type: 'desktop' | 'desktopoverlay' | 'gamepad';
+    setNavigatingToInitialRoute(value: boolean): void;
+    AllCollections(): void;
+    App(appId: number): void;
+    AppProperties(appId: number): void;
+    Chat(): void;
+    Collection(id: string): void;
+    Console(): void;
+    Downloads(): void;
+    ExternalWeb(url: string): void;
+    FriendAchievements(appid: number, steamid64: string): void;
+    GameServers(): void;
+    GlobalAchievements(appId: number): void;
+    Home(): void;
+    Media: {
+        Clip(state: NavigatorRouterState<{
+            id: string;
+        }>): void;
+        Grid(state: NavigatorRouterState<{
+            filter: MediaManagerFilter;
+        }>): void;
+        List(state: NavigatorRouterState<{
+            filter: MediaManagerFilter;
+        }>): void;
+        Screenshot(state: NavigatorRouterState<{
+            id: string;
+        }>): void;
+        Recording(state: NavigatorRouterState<{
+            gameid: string;
+            playbackDefinition?: Partial<PlaybackDefinition_t>;
+        }>): void;
+    };
+    MyAchievements(appId: number): void;
+    RequestPlaytimeDialog(connectString: string): void;
+    Settings(section?: SettingsSection_t): void;
+    SteamWeb(url: string): void;
+    SteamWebTab(url: string): void;
+}
+interface SteamWindowNavigator_GamepadOnly {
+    Account(): void;
+    AppOverlay: {
+        AppRunningControls(): void;
+    };
+    ControllerConfigurator: {
+        Main(appId: number): void;
+    };
+    Invites(): void;
+    LibraryTab(tab: 'AllGames' | 'Collections' | 'DesktopApps' | 'Favorites' | 'Installed' | 'Soundtracks'): void;
+    Login(): void;
+    MTXAuth(url: string): void;
+    Reauthentication(): void;
+    RemotePlayTogether(): void;
+}
+interface SteamWindowNotificationPosition {
+    horizontalInset: number;
+    position: ENotificationPosition;
+    verticalInset: number;
+}
+interface SteamUIWindowParams {
+    appid: number;
+    bSimulateOnDesktop: boolean;
+    bViaGamescope: boolean;
+    browserInfo: BrowserContext;
+    eWindowType: EWindowType;
+    flDisplayScale: number;
+    gameid: string;
+    nScreenHeight: number;
+    nScreenWidth: number;
+    strUserAgentIdentifier: string;
+}
+export interface SteamUIWindowInstance {
+    m_BrowserWindow: Window;
+    m_bIsGamepadApplicationUIInitialized: boolean;
+    m_locationPathname: string;
+    m_Navigator: SteamWindowNavigator & SteamWindowNavigator_GamepadOnly;
+    m_notificationPosition: SteamWindowNotificationPosition;
+    m_params: Partial<SteamUIWindowParams>;
+    m_VirtualKeyboardManager: any;
+    BCanPopVRDashboardForCurrentPath(): boolean;
+    BHasMenus(): boolean;
+    BIsGamepadApplicationUIInitialized(): boolean;
+    BIsOverlayPath(): boolean;
+    BRouteMatch(routes: string[]): boolean;
+    BUseSeparateOverlayWindows(): boolean;
+    BViewingPreLoginRoute(): boolean;
+    CreateBrowserView(name: string, options: BrowserViewCreateOptions): CGamepadBrowserView;
+    FocusApplicationRoot(): void;
+    GetMainVROverlayKey(): string | undefined;
+    GetShowingGlobalModal(): boolean;
+    GetStoreBrowser(): CGamepadBrowserView;
+    IsControllerConfiguratorWindow(): boolean;
+    IsDesktopLoginWindow(): boolean;
+    IsDesktopOverlayWindow(): boolean;
+    IsDesktopUIWindow(): boolean;
+    IsGamepadUIOverlayWindow(): boolean;
+    IsGamepadUIWindow(): boolean;
+    IsMainDesktopWindow(): boolean;
+    IsMainGamepadUIWindow(): boolean;
+    IsStandaloneKeyboardWindow(): boolean;
+    IsSteamChinaReviewLauncher(): boolean;
+    IsVRSimulatedOnDesktopWindow(): boolean;
+    IsVRWindow(): boolean;
+    IsVRWindowInGamescope(): boolean;
+    Navigate(path: string, replaceHistoryEntry: boolean, matchRoute: boolean, state?: SteamBrowserHistoryState): void;
+    NavigateBack(): void;
+    NavigateHistory(delta: number): void;
+    NavigateToRunningApp(replaceHistoryEntry: boolean): void;
+    NavigateToStandaloneAppRunningControls(e?: boolean): void;
+    NavigateToSteamWeb: SteamWindowNavigator['SteamWeb'];
+    NavigateWithoutChangingFocus: this['Navigate'];
+    SetBrowserWindow(value: Window): void;
+    SetNavigator(value: SteamWindowNavigator & SteamWindowNavigator_GamepadOnly): void;
+    SetNotificationPosition(pos: ENotificationPosition, horizontalInset: number, verticalInset: number): void;
+    SetShowingGlobalModal(value: boolean): void;
+    SetStoreBrowserGlass(openSideMenu: EOpenSideMenu): void;
+    get BrowserWindow(): Window;
+    get MenuStore(): CMenuStore;
+}
+interface AppWindow {
+    appid: number;
+    focusedWindowID: number;
+    windowids: number[];
+}
+export declare class CWindowStore {
+    m_Parent: any;
+    m_mapAppOverlayPosition: Map<number, SteamWindowNotificationPosition>;
+    m_mapAppWindows: Map<number, AppWindow>;
+    m_mapDesiredWindowInstances: Map<number, SteamUIWindowInstance>;
+    m_mapDesiredWindows: Map<number, SteamWindow>;
+    m_mapOverlayPopupByPID: Map<number, SteamUIWindowInstance>;
+    m_simulatedVRGamepadUIOnDesktopInstance: SteamUIWindowInstance | undefined;
+    AddTestWindowsOverlayBrowser(appid: number): void;
+    BHasAppWindow(appid: number): boolean;
+    BHasGamepadUIMainWindow(): boolean;
+    BHasOverlayWindowForApp(appid: number): boolean;
+    BHasStandaloneConfiguratorWindow(): boolean;
+    BHasStandaloneKeyboard(): boolean;
+    BHasVRWindow(): boolean;
+    CreateDesktopLoginWindow(browser: BrowserContext): SteamUIWindowInstance;
+    CreateMainDesktopWindow(browser: BrowserContext): SteamUIWindowInstance;
+    CreateMainGamepadUIWindow(browser: BrowserContext): SteamUIWindowInstance;
+    CreateSimulatedVRWindow(): SteamUIWindowInstance;
+    CreateStandaloneControllerConfiguratorWindow(browser: BrowserContext, appid: number, appName: string): SteamUIWindowInstance;
+    CreateStandaloneKeyboardWindow(browser: BrowserContext, initialX: number, initialY: number): SteamUIWindowInstance;
+    CreateSteamChinaReviewLauncherWindow(browser: BrowserContext): SteamUIWindowInstance;
+    CreateVRWindow(browser: BrowserContext, viaGamescope: boolean): SteamUIWindowInstance;
+    DEBUG_DumpDesiredSteamUIWindows(): Promise<any>;
+    EnsureMainWindowCreated(forceOSWindowFocus: boolean): void;
+    GetAppFocusedWindowID(appid: number): number;
+    GetAppWindowIDs(appid: number): number[];
+    GetControllerConfiguratorWindowFromAppID(appid: number): SteamUIWindowInstance;
+    GetInstanceForPID(pid: number): SteamUIWindowInstance;
+    GetOverlayInstance(appid: number, pid: number): SteamUIWindowInstance;
+    GetOverlayInstanceWithFallback(appid?: number, pid?: number): SteamUIWindowInstance;
+    GetOverlayInstances(appid: number): SteamUIWindowInstance[];
+    GetSimultedVRWindowInstance(): this['m_simulatedVRGamepadUIOnDesktopInstance'];
+    GetSteamUIWindowByType(type: EWindowType): SteamUIWindowInstance | undefined;
+    GetVRWindowInstance(): SteamUIWindowInstance | undefined;
+    GetWindowInstanceFromWindow(wnd: Window): SteamUIWindowInstance | null;
+    RemoveRunningAppWindowIDs(appid: number): void;
+    SetFocusedAppWindowID(appid: number, windowid: number): void;
+    SetRunningAppWindowIDs(appid: number, windowids: number[]): void;
+    UpdateDesiredWindows(windows: SteamWindow[]): void;
+    get GamepadUIMainWindowInstance(): SteamUIWindowInstance;
+    get GamepadUIVRWindowInstance(): SteamUIWindowInstance;
+    get MainRunningAppWindowIDs(): number[] | undefined;
+    get MainWindowInstance(): SteamUIWindowInstance;
+    get OverlayWindows(): SteamUIWindowInstance[];
+    get SteamUIWindows(): SteamUIWindowInstance[];
+}
+export {};

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

@@ -0,0 +1,6 @@
+export var EOpenSideMenu;
+(function (EOpenSideMenu) {
+    EOpenSideMenu[EOpenSideMenu["None"] = 0] = "None";
+    EOpenSideMenu[EOpenSideMenu["Main"] = 1] = "Main";
+    EOpenSideMenu[EOpenSideMenu["QuickAccess"] = 2] = "QuickAccess";
+})(EOpenSideMenu || (EOpenSideMenu = {}));

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

@@ -0,0 +1,319 @@
+import type { ServiceTransport } from '../shared';
+import type { EAppType, ESteamDeckCompatibilityCategory } from '../steam-client/App';
+import type { ELanguage } from '../steam-client/Settings';
+import type { EResult } from '../steam-client/shared';
+export declare enum ESteamOSCompatibilityCategory {
+    k_ESteamOSCompatibilityCategory_Unknown = 0,
+    k_ESteamOSCompatibilityCategory_Unsupported = 1,
+    k_ESteamOSCompatibilityCategory_Compatible = 2
+}
+export declare enum EStoreItemType {
+    k_EStoreItemType_Invalid = -1,
+    k_EStoreItemType_App = 0,
+    k_EStoreItemType_Package = 1,
+    k_EStoreItemType_Bundle = 2,
+    k_EStoreItemType_Mtx = 3,
+    k_EStoreItemType_Tag = 4,
+    k_EStoreItemType_Creator = 5,
+    k_EStoreItemType_HubCategory = 6
+}
+declare class StoreBrowseItemDataRequest {
+}
+interface StoreItemAssets {
+    ConstructAssetURL(urlFormat: string, name: string): string | undefined;
+    GetCommunityIconURL(): string | undefined;
+    GetCommunityIconURL_Full(): string | undefined;
+    GetHeaderURL(): string | undefined;
+    GetHeroCapsuleURL(): string | undefined;
+    GetHeroCapsuleURL_2x(): string | undefined;
+    GetLibraryCapsuleURL(): string | undefined;
+    GetLibraryCapsuleURL_2x(): string | undefined;
+    GetLibraryHeroURL(): string | undefined;
+    GetLibraryHeroURL_2x(): string | undefined;
+    GetMainCapsuleURL(): string | undefined;
+    GetPackageHeaderURL(): string | undefined;
+    GetPageBackgroundURL(): string | undefined;
+    GetRawPageBackgroundURL(): string | undefined;
+    GetSmallCapsuleURL(): string | undefined;
+}
+export interface CStoreItem {
+    k_regexSalePage: RegExp;
+    m_Assets: StoreItemAssets | undefined;
+    m_AssetsWithoutOverrides: StoreItemAssets | undefined;
+    m_BasicInfo: {
+        developers: {
+            name: string;
+        }[];
+        franchises: {
+            creator_clan_account_id: number;
+            name: string;
+        }[];
+        publishers: {
+            creator_clan_account_id: number;
+            name: string;
+        }[];
+        short_description: string;
+    };
+    m_BestPurchaseOption: {
+        active_discounts: {
+            discount_amount: string;
+            discount_description: string;
+            discount_end_date: number;
+        }[];
+        discount_pct: number;
+        final_price_in_cents: string;
+        formatted_final_price: string;
+        formatted_original_price: string;
+        hide_discount_pct_for_compliance: boolean;
+        included_game_count: number;
+        original_price_in_cents: string;
+        packageid: number;
+        purchase_option_name: string;
+        user_can_purchase_as_gift: boolean;
+    };
+    m_ContentDescriptorIDs: any[];
+    m_DataRequested: {
+        include_assets: boolean;
+        include_basic_info: boolean;
+        include_tag_count: number;
+    };
+    m_Platforms: {
+        windows: boolean;
+        mac: boolean;
+        steamos_linux: boolean;
+        vr_support: {
+            vrhmd: boolean;
+            vrhmd_only: boolean;
+            htc_vive: boolean;
+            oculus_rift: boolean;
+            windows_mr: boolean;
+            valve_index: boolean;
+        };
+        steam_deck_compat_category: ESteamDeckCompatibilityCategory;
+        steam_os_compat_category: ESteamOSCompatibilityCategory;
+    };
+    m_RelatedItems: {
+        demo_appid: any[];
+        standalone_demo_appid: any[];
+    };
+    m_ReleaseInfo: any;
+    m_ReviewInfo: any;
+    m_Screenshots: any;
+    m_SelfPurchaseOption: any;
+    m_StoreCategories: {
+        controller_categoryids: number[];
+        feature_categoryids: number[];
+        supported_player_categoryids: number[];
+    };
+    m_Trailers: any;
+    m_bIsComingSoon: boolean;
+    m_bIsEarlyAccess: boolean;
+    m_bIsFree: boolean;
+    m_bIsFreeTemporary: boolean;
+    m_bVisible: boolean;
+    m_eAppType: EAppType;
+    m_eItemType: EStoreItemType;
+    m_freeWeekend: {};
+    m_rgIncludedAppIDs: any[];
+    m_rgIncludedAppTypes: any[];
+    m_rgLinks: any;
+    m_rgPurchaseOptions: any;
+    m_rgStoreTagIDs: any[];
+    m_rgStoreTags: any[];
+    m_rgSupportedLanguages: any;
+    m_strInternalName: string;
+    m_strName: string;
+    m_strStoreURLPath: string;
+    m_strStoreURLPathOverride: string;
+    m_unAppID: number;
+    m_unID: number;
+    m_userFilterFailure: any;
+    BCheckDataRequestIncluded(msg: StoreBrowseItemDataRequest): boolean;
+    BContainDataRequest(msg: StoreBrowseItemDataRequest): boolean;
+    BHasAgeSafeScreenshots(): boolean;
+    BHasDemo(): boolean;
+    BHasHighlightTrailers(param0: any): boolean;
+    BHasSomeLanguageSupport(lang: ELanguage): boolean;
+    BHasStoreCategory(category: number): boolean;
+    BHasTags(): boolean;
+    BHasTrailers(param0: any): boolean;
+    BIsAgeSafeScreenshot(param0: any): boolean;
+    BIsApplicationOrTool(): boolean;
+    BIsComingSoon(): boolean;
+    BIsCustomComingSoonDisplay(): boolean;
+    BIsEarlyAccess(): boolean;
+    BIsFree(): boolean;
+    BIsFreeTemporary(): boolean;
+    BIsFreeWeekend(): boolean;
+    BIsPrePurchase(): boolean;
+    BIsReleased(): boolean;
+    BIsSalePage(): boolean;
+    BIsVisible(): boolean;
+    BLimitedLaunchActive(): boolean;
+    GetAllCreatorClanIDs(): number[];
+    GetAllDeveloperCreatorClans(): number[];
+    GetAllFranchiseCreatorClans(): number[];
+    GetAllLanguagesWithSomeSupport(): any[];
+    GetAllPublisherCreatorClans(): number[];
+    GetAllPurchaseOptions(): this['m_rgPurchaseOptions'];
+    GetAllTrailers(): this['m_Trailers'];
+    GetAppID(): number;
+    GetAppIDToRun(): number;
+    GetAppType(): EAppType;
+    GetAssets(): this['m_Assets'];
+    GetAssetsWithoutOverrides(): this['m_AssetsWithoutOverrides'];
+    GetBestPurchaseOption(): this['m_BestPurchaseOption'];
+    GetBestPurchaseOriginalPriceFormatted(): string;
+    GetBestPurchaseOriginalPriceInCents(): number;
+    GetBestPurchasePriceFormatted(): string;
+    GetBestPurchasePriceInCents(): number;
+    GetCapsuleHeadline(): any;
+    GetCommunityDiscussionForumsURL(): string;
+    GetCommunityPageURL(): string;
+    GetContentDescriptorIDs(): any[];
+    GetDataRequest(): this['m_DataRequested'];
+    GetDemoAppIDs(): number[];
+    GetDemoStandaloneStorePageAppIDs(): number[];
+    GetDeveloperNames(): string[];
+    GetFilteredReviewSummary(): any;
+    GetFilteredReviewSummaryLanguage(): any;
+    GetFormattedSteamReleaseDate(): string;
+    GetFranchiseNames(): string[];
+    GetFreeWeekendEnd(): any;
+    GetFreeWeekendPlayTextOverride(): any;
+    GetID(): number;
+    GetIncludedAppIDs(): number[];
+    GetIncludedAppIDsOrSelf(): number[];
+    GetIncludedAppTypes(): EAppType[];
+    GetInternalName(): any;
+    GetLinks(): any;
+    GetMicroTrailer(e: any): any | null;
+    GetName(): string;
+    GetOriginalReleaseDateRTime(): any;
+    GetParentAppID(): number;
+    GetPlatforms(): this['m_Platforms'];
+    GetPublisherNames(): string[];
+    GetReleaseDateRTime(e?: boolean): number;
+    GetSalePageVanityURL(): string;
+    GetScreenshots(e: any): any[];
+    GetSelfPurchaseOption(): any;
+    GetShortDescription(): string;
+    GetStoreCategories_Controller(): number[];
+    GetStoreCategories_Features(): number[];
+    GetStoreCategories_SupportedPlayers(): number[];
+    GetStoreItemType(): EStoreItemType;
+    GetStorePageURL(demoPage?: boolean): string;
+    GetStorePageURLOverride(): string;
+    GetStorePageURLWithOverride(): string;
+    GetTagIDs(): any[];
+    GetTags(): any[];
+    GetUnfilteredReviewSummary(): any;
+    GetUniqueID(): string;
+    GetUserFilterFailure(): any;
+    HasContentDescriptorID(param0: any): boolean;
+    HasDemoStandaloneStorePage(): boolean;
+    MergeData(e: any, t: any): void;
+    ReplaceBestPurchaseOption(e: any): void;
+}
+export interface CStoreItemCache {
+    k_AlreadyResolvedBusy: Promise<EResult>;
+    k_AlreadyResolvedInvalid: Promise<EResult>;
+    k_AlreadyResolvedOK: Promise<EResult>;
+    k_QueueWaitUntilRequestMS: number;
+    k_nMaxBatchSize: number;
+    m_PendingInfoPromise: any;
+    m_PendingInfoResolve: any;
+    m_PendingTimer: any;
+    m_bActivelyResettingCache: boolean;
+    m_bInitialized: boolean;
+    m_bReturnUnavailableItems: boolean;
+    m_bUsePartnerAPI: boolean;
+    m_mapApps: Map<number, CStoreItem>;
+    m_mapAppsInFlight: Map<number, CStoreItem>;
+    m_mapBundleInFlight: Map<number, CStoreItem>;
+    m_mapBundles: Map<number, CStoreItem>;
+    m_mapCreators: Map<number, CStoreItem>;
+    m_mapCreatorsInFlight: Map<number, CStoreItem>;
+    m_mapHubCategories: Map<number, CStoreItem>;
+    m_mapHubCategoriesInFlight: Map<number, CStoreItem>;
+    m_mapPackageInFlight: Map<number, CStoreItem>;
+    m_mapPackages: Map<number, CStoreItem>;
+    m_mapTags: Map<number, CStoreItem>;
+    m_mapTagsInFlight: Map<number, CStoreItem>;
+    m_serviceTransport: ServiceTransport;
+    m_setPendingAppInfo: Set<number>;
+    m_setPendingBundleInfo: Set<number>;
+    m_setPendingCreatorInfo: Set<number>;
+    m_setPendingDataRequest: Set<number>;
+    m_setPendingHubCategoryInfo: Set<number>;
+    m_setPendingPackageInfo: Set<number>;
+    m_setPendingTagInfo: Set<number>;
+    m_setUnavailableApps: Set<number>;
+    m_setUnavailableBundles: Set<number>;
+    m_setUnavailableCreators: Set<number>;
+    m_setUnavailableDueToCountryRestrictionApps: Set<number>;
+    m_setUnavailableDueToCountryRestrictionBundles: Set<number>;
+    m_setUnavailableDueToCountryRestrictionPackages: Set<number>;
+    m_setUnavailableHubCategories: Set<number>;
+    m_setUnavailablePackages: Set<number>;
+    m_setUnavailableTags: Set<number>;
+    BHasApp(appid: number, msg: StoreBrowseItemDataRequest): boolean;
+    BHasBundle(appid: number, msg: StoreBrowseItemDataRequest): boolean;
+    BHasCreator(appid: number, msg: StoreBrowseItemDataRequest): boolean;
+    BHasHubCategory(appid: number, msg: StoreBrowseItemDataRequest): boolean;
+    BHasPackage(appid: number, msg: StoreBrowseItemDataRequest): boolean;
+    BHasStoreItem(appid: number, type: EStoreItemType, msg: StoreBrowseItemDataRequest): boolean;
+    BHasTag(appid: number, msg: StoreBrowseItemDataRequest): boolean;
+    BIsAppMissing(appid: number): boolean;
+    BIsAppUnavailableDueToCountryRestriction(appid: number): boolean;
+    BIsBundleMissing(appid: number): boolean;
+    BIsBundleUnavailableDueToCountryRestriction(appid: number): boolean;
+    BIsCreatorMissing(appid: number): boolean;
+    BIsHubCategoryMissing(appid: number): boolean;
+    BIsPackageMissing(appid: number): boolean;
+    BIsPackageUnavailableDueToCountryRestriction(appid: number): boolean;
+    BIsStoreItemMissing(appid: number, type: EStoreItemType): boolean;
+    BIsStoreItemUnavailableDueToCountryRestriction(appid: number, type: EStoreItemType): boolean;
+    BIsTagMissing(appid: number): boolean;
+    FlushPendingInfo(): Promise<void>;
+    GetApp(appid: number): CStoreItem;
+    GetBundle(appid: number): CStoreItem;
+    GetCreator(appid: number): CStoreItem;
+    GetHubCategory(appid: number): CStoreItem;
+    GetMapForType(appid: number, type: EStoreItemType): Map<number, CStoreItem>;
+    GetPackage(appid: number): CStoreItem;
+    GetPreviousSupersetLoadPromise(appid: number, type: EStoreItemType, msg: StoreBrowseItemDataRequest): Promise<EResult> | null;
+    GetReturnUnavailableItems(): boolean;
+    GetServiceTransport(): ServiceTransport;
+    GetStoreItem(appid: number, type: EStoreItemType): CStoreItem;
+    GetStoreItemDataRequest(appid: number, type: EStoreItemType): CStoreItem['m_DataRequested'] | null;
+    GetStoreItemWithLegacyVisibilityCheck(appid: number, type: EStoreItemType): CStoreItem | undefined;
+    GetTag(appid: number): CStoreItem;
+    HintLoadStoreApps(apps: number[], msg: StoreBrowseItemDataRequest): Promise<EResult | undefined>;
+    HintLoadStoreBundles(bundles: number[], msg: StoreBrowseItemDataRequest): Promise<EResult | undefined>;
+    HintLoadStoreItems(apps: number[] | null, packages: number[] | null, bundles: number[] | null, tags: number[] | null, creators: number[] | null, hubCategories: number[] | null, msg: StoreBrowseItemDataRequest): Promise<EResult | undefined>;
+    HintLoadStorePackages(packages: number[], msg: StoreBrowseItemDataRequest): Promise<EResult | undefined>;
+    InternalHandleLoadStoreItems(msg1: any, msg2: StoreBrowseItemDataRequest): Promise<any>;
+    MarkStoreItemIDUnavailable(msgs: any[]): void;
+    QueueAppRequest(appid: number, msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueBundleRequest(appid: number, msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueCreatorRequest(appid: number, msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueHubCategoryRequest(appid: number, msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueMultipleAppRequests(appids: number[], msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueMultipleBundleRequests(appids: number[], msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueMultipleCreatorRequests(appids: number[], msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueMultipleHubCategoryRequests(appids: number[], msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueMultiplePackageRequests(appids: number[], msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueMultipleStoreItemRequests(appids: number[], type: EStoreItemType, msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueMultipleTagRequests(appids: number[], msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueuePackageRequest(appid: number, msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueStoreItemRequest(appid: number, type: EStoreItemType, msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    QueueTagRequest(appid: number, msg: StoreBrowseItemDataRequest): Promise<EResult>;
+    ReadResults(e: any[], t: any): any[];
+    ResetCache(): Promise<void>;
+    SetReturnUnavailableItems(value: boolean): void;
+    SetServiceTransport(value: ServiceTransport): void;
+    SetSteamInterface(value: any): void;
+    SortStoreItems(msg: StoreBrowseItemDataRequest): any;
+}
+export {};

package/dist/globals/stores/storeitemcache.js

@@ -0,0 +1,17 @@
+export var ESteamOSCompatibilityCategory;
+(function (ESteamOSCompatibilityCategory) {
+    ESteamOSCompatibilityCategory[ESteamOSCompatibilityCategory["k_ESteamOSCompatibilityCategory_Unknown"] = 0] = "k_ESteamOSCompatibilityCategory_Unknown";
+    ESteamOSCompatibilityCategory[ESteamOSCompatibilityCategory["k_ESteamOSCompatibilityCategory_Unsupported"] = 1] = "k_ESteamOSCompatibilityCategory_Unsupported";
+    ESteamOSCompatibilityCategory[ESteamOSCompatibilityCategory["k_ESteamOSCompatibilityCategory_Compatible"] = 2] = "k_ESteamOSCompatibilityCategory_Compatible";
+})(ESteamOSCompatibilityCategory || (ESteamOSCompatibilityCategory = {}));
+export var EStoreItemType;
+(function (EStoreItemType) {
+    EStoreItemType[EStoreItemType["k_EStoreItemType_Invalid"] = -1] = "k_EStoreItemType_Invalid";
+    EStoreItemType[EStoreItemType["k_EStoreItemType_App"] = 0] = "k_EStoreItemType_App";
+    EStoreItemType[EStoreItemType["k_EStoreItemType_Package"] = 1] = "k_EStoreItemType_Package";
+    EStoreItemType[EStoreItemType["k_EStoreItemType_Bundle"] = 2] = "k_EStoreItemType_Bundle";
+    EStoreItemType[EStoreItemType["k_EStoreItemType_Mtx"] = 3] = "k_EStoreItemType_Mtx";
+    EStoreItemType[EStoreItemType["k_EStoreItemType_Tag"] = 4] = "k_EStoreItemType_Tag";
+    EStoreItemType[EStoreItemType["k_EStoreItemType_Creator"] = 5] = "k_EStoreItemType_Creator";
+    EStoreItemType[EStoreItemType["k_EStoreItemType_HubCategory"] = 6] = "k_EStoreItemType_HubCategory";
+})(EStoreItemType || (EStoreItemType = {}));

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

@@ -0,0 +1,57 @@
+import type { EParentalFeature } from '../steam-client/Parental';
+import type { SteamWebURL_t } from '../steam-client/URL';
+type SteamURLs_t = {
+    [url in SteamWebURL_t]: {
+        feature: EParentalFeature;
+        regexMatchURL: RegExp;
+        url: string;
+    };
+};
+type SteamURLsLowercase_t = {
+    [url in Lowercase<SteamWebURL_t>]: {
+        bDuplicate: boolean;
+        feature: EParentalFeature;
+        url: string;
+    };
+};
+export interface CURLStore {
+    m_nGeneration: number;
+    m_steamUrls: SteamURLs_t & SteamURLsLowercase_t;
+    BIsSteamURL(url: string): boolean;
+    BuildAppPointsShopURL(appId: number): string;
+    BuildCachedLibraryAssetURL(appId: number, assetName: string, timestamp: number): string;
+    BuildCachedStoreAssetURL(appId: number, assetName: string, timestamp: number): string;
+    BuildCustomAssetURL(appId: number, assetName: string, extension: string, timestamp: number): string;
+    BuildLegacyCachedLibraryAssetURL(appId: number, icon: string, timestamp: number): string;
+    BuildLibraryAssetURL(appId: number, icon: string, timestamp: number): string;
+    BuildSteamURL(name: SteamWebURL_t, ...args: string[]): string;
+    BuildStoreAppDlcURL(appId: number, navParam: string): string;
+    BuildStoreAppURL(appId: number, navParam: string): string;
+    BuildStoreAssetURL(appId: number, assetName: string): string;
+    GetAvatarBaseURL(): string;
+    GetBaseURLSharedCDN(): string;
+    GetClanCDNAssetURL(): string;
+    GetCommunityCDNAssetURL(): string;
+    GetCommunityCDNURL(): string;
+    GetCommunityImageURL(): string;
+    GetCommunityURL(): string;
+    GetHelpURL(): string;
+    GetMatchingUrls(url: string): {
+        length: number;
+        urlid: SteamWebURL_t;
+    }[];
+    GetMediaCDNUrl(): string;
+    GetParentalFeature(name: SteamWebURL_t): EParentalFeature;
+    GetParentalFeatureForFullUrl(url: string): EParentalFeature;
+    GetStoreAppImageURL(): string;
+    GetStoreCDNURL(): string;
+    GetStoreGreatOnDeckURL(): string;
+    GetStoreIconBaseURL(): string;
+    GetStoreURL(): string;
+    GetStoreVRURL(): string;
+    GetVideoCDNAssetURL(): string;
+    GetWebApiURL(): string;
+    NavigateToSteamURLInOwningWindow(ev: Event, name: SteamWebURL_t): void;
+    ResolveURL(name: SteamWebURL_t, ...args: string[]): string;
+}
+export {};

package/dist/globals/stores/urlstore.js

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

package/dist/modules/Router.d.ts

@@ -1,59 +1,6 @@
-import { EDisplayStatus } from "../globals/steam-client/App";
-export declare enum SideMenu {
-    None = 0,
-    Main = 1,
-    QuickAccess = 2
-}
-export declare enum QuickAccessTab {
-    Notifications = 0,
-    RemotePlayTogetherControls = 1,
-    VoiceChat = 2,
-    Friends = 3,
-    Settings = 4,
-    Perf = 5,
-    Help = 6,
-    Music = 7,
-    Decky = 999
-}
-export type AppOverview = {
-    appid: string;
-    display_name: string;
-    display_status: EDisplayStatus;
-    sort_as: string;
-};
-export interface MenuStore {
-    OpenSideMenu(sideMenu: SideMenu): void;
-    OpenQuickAccessMenu(quickAccessTab?: QuickAccessTab): void;
-    OpenMainMenu(): void;
-}
-export interface WindowRouter {
-    BrowserWindow: Window;
-    MenuStore: MenuStore;
-    Navigate(path: string): void;
-    NavigateToChat(): void;
-    NavigateToSteamWeb(url: string): void;
-    NavigateBack(): void;
-}
-export interface WindowStore {
-    GamepadUIMainWindowInstance?: WindowRouter;
-    SteamUIWindows: WindowRouter[];
-    OverlayWindows: WindowRouter[];
-}
-export interface Router {
-    WindowStore?: WindowStore;
-    CloseSideMenus(): void;
-    Navigate(path: string): void;
-    NavigateToAppProperties(): void;
-    NavigateToExternalWeb(url: string): void;
-    NavigateToInvites(): void;
-    NavigateToChat(): void;
-    NavigateToLibraryTab(): void;
-    NavigateToLayoutPreview(e: unknown): void;
-    OpenPowerMenu(unknown?: any): void;
-    get RunningApps(): AppOverview[];
-    get MainRunningApp(): AppOverview | undefined;
-}
-export declare const Router: Router;
+import type { CSteamUIStore } from "../globals/stores/steamuistore";
+import type { QuickAccessTab, SideMenu } from "../globals/stores/steamuistore/menu";
+export declare const Router: CSteamUIStore;
 export interface Navigation {
     Navigate(path: string): void;
     NavigateBack(): void;