@decky/ui 4.15.1 → 4.16.1

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

@@ -0,0 +1,18 @@
+export * from './app';
+export * from './appdetailsstore';
+export * from './appstore';
+export * from './badgestore';
+export * from './collectionstore';
+export * from './consolestore';
+export * from './focusnavcontroller';
+export * from './friendstore';
+export * from './gamerecordingstore';
+export * from './libraryuistore';
+export * from './localizationmanager';
+export * from './mainwindowbrowsermanager';
+export * from './notificationstore';
+export * from './popupmanager';
+export * from './securitystore';
+export * from './settingsstore';
+export * from './steamuistore';
+export * from './urlstore';

package/dist/globals/stores/index.js

@@ -0,0 +1,18 @@
+export * from './app';
+export * from './appdetailsstore';
+export * from './appstore';
+export * from './badgestore';
+export * from './collectionstore';
+export * from './consolestore';
+export * from './focusnavcontroller';
+export * from './friendstore';
+export * from './gamerecordingstore';
+export * from './libraryuistore';
+export * from './localizationmanager';
+export * from './mainwindowbrowsermanager';
+export * from './notificationstore';
+export * from './popupmanager';
+export * from './securitystore';
+export * from './settingsstore';
+export * from './steamuistore';
+export * from './urlstore';

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

@@ -0,0 +1,179 @@
+import type { CSteamID } from '../shared';
+import type { CMInterface } from '../shared/cm';
+import type { CUserLocalStorage } from '../shared/storage';
+import type { EAppType } from '../steam-client/App';
+import type { CCollection, CCollectionBase, CCollectionFilterBase, CDynamicCollectionFilter, FilterOptionByIndex_t, FilterSpec_t } from './collectionstore';
+import type { SteamUIWindowInstance } from './steamuistore/window';
+import type { CStoreItem } from './storeitemcache';
+declare enum EGameListView {
+    kNormal = 1,
+    kSingleCollection = 10,
+    kSearchResults = 11
+}
+export declare enum EAppPropertiesSection {
+    General = "general",
+    Compatibility = "compatibility",
+    Updates = "updates",
+    LocalFiles = "localfiles",
+    Language = "language",
+    Betas = "betas",
+    Controller = "controller",
+    Shortcut = "shortcut",
+    Dlc = "dlc",
+    Workshop = "workshop",
+    Feedback = "feedback"
+}
+export declare enum EControllerConfiguratorSection {
+    Main = "Main",
+    Summary = "Summary",
+    Preview = "Preview",
+    ActionSets = "ActionSets",
+    Buttons = "Buttons",
+    Triggers = "Triggers",
+    Sticks = "Sticks",
+    Touchpads = "Touchpads",
+    Gyroscopes = "Gyroscopes",
+    VirtualMenus = "VirtualMenus",
+    ChooseBinding = "ChooseBinding"
+}
+export declare enum ESettingsZooSection {
+    Dropdowns = "Dropdowns",
+    Modals = "Modals",
+    Buttons = "Buttons",
+    Sliders = "Sliders",
+    Toggles = "Toggles",
+    OtherControls = "Misc",
+    Glyphs = "Glyphs",
+    SVG = "SVG",
+    Input = "Input",
+    Type = "Type"
+}
+export declare enum ESettingsZooDevSection {
+    DeveloperOptions = "DeveloperOptions",
+    VRDeveloperOptions = "VRDeveloperOptions",
+    AppSpotlight = "AppSpotlight",
+    PlayNext = "PlayNext",
+    Notifications = "Notifications",
+    Share = "Share"
+}
+interface GameListSelection_t {
+    nAppId: number;
+    strCollectionId: string;
+}
+interface LibraryState_t {
+    bGroupedByCollection: boolean;
+    bGroupBySharedLibraries: boolean;
+    bSortedByRecent: boolean;
+    collectionFilter: FilterSpec_t;
+    collectionFilterGamepad: FilterSpec_t;
+    currentSelection: GameListSelection_t;
+    eGameListView: EGameListView;
+    mapCollapsedState: Record<string, boolean>;
+    nVersion: number;
+}
+interface NavigateLibraryArgsMap_t {
+    collection: number;
+    details: string;
+    downloads: undefined;
+    'dynamic-collection': any;
+    event: string;
+    games: undefined;
+    library: undefined;
+    media: undefined;
+    recent: undefined;
+    'shared-apps': any;
+    view: 'all' | 'all-collections' | 'games' | 'installed' | 'login' | 'recent' | 'software' | 'soundtracks' | 'tools' | 'videos';
+    appproperties: string;
+    apprunning: undefined;
+    controllerconfigurator: string;
+    gamepadapiosk: undefined;
+    search: undefined;
+    settings: 'general' | 'display' | 'internet' | 'bluetooth' | 'audio' | 'storage' | 'system' | 'internal' | 'developer' | 'controller' | 'downloads' | 'remoteplay' | 'library' | 'family';
+    settingszoo: ESettingsZooSection | ESettingsZooDevSection;
+}
+export interface CLibraryUIStore {
+    m_RecentGamesFirstApp: number;
+    m_bGameListGroupedByCollection: boolean;
+    m_bGameListGroupedBySharedLibraries: boolean;
+    m_bGameListSortedByRecent: boolean;
+    m_bIsCollectionEditorOpen: boolean;
+    m_bIsCollectionRenameOpen: boolean;
+    m_bIsSearchByTypePaneOpen: boolean;
+    m_cm: CMInterface;
+    m_collectionsAppFilter: CCollectionFilterBase;
+    m_collectionsAppFilterGamepad: CCollectionFilterBase;
+    m_currentAppFilter: CCollectionFilterBase;
+    m_eSelectedGameListView: EGameListView;
+    m_gameListSelection: GameListSelection_t;
+    m_latchedMostRecentApp: number;
+    m_localStorage: CUserLocalStorage;
+    m_mapLibrarySectionCollapseState: Map<string, boolean>;
+    m_setClientSuggestionIds: Set<number>;
+    m_setStoreSuggestionIds: Set<number>;
+    m_setStoreSuggestions: CStoreItem[];
+    BIsSearchByTypeActive(): boolean;
+    BIsSearchByTypePaneOpen(): boolean;
+    BIsSuggestionVisible(appid: number): boolean;
+    BIsTextSearchActive(): boolean;
+    CleanupCollapseStateMap(): void;
+    CollapseAll(): void;
+    EnsureLargeMode(): void;
+    ExitSearch(): void;
+    ExpandAll(): void;
+    ExpandOrCollapseAll(collapse: boolean): void;
+    FetchSearchSuggestions(query: string): Promise<void>;
+    GetActiveWindowInstance(): SteamUIWindowInstance;
+    GetCollectionList(): Array<CCollectionBase | CCollection>;
+    GetRecentGamesFirstApp(): number;
+    GetVisibleCollections(): Array<CCollectionBase | CCollection>;
+    InitializeAppFilter(state: LibraryState_t, param1?: boolean): CCollectionFilterBase;
+    IsCollapsed(collectionId: string): boolean;
+    IsGamepadUIWindowActive(wnd?: SteamUIWindowInstance): boolean;
+    NavigateForward(): void;
+    NavigateLibrary<K extends keyof NavigateLibraryArgsMap_t>(wnd: SteamUIWindowInstance | null, key: K, value?: NavigateLibraryArgsMap_t[K]): void;
+    NavigateToCollectionSaveDialog(param0: string): void;
+    NavigateToSharedAppsDesktopUI(json: string): void;
+    PreserveNavigation(): void;
+    ResetSearch(): void;
+    RestoreNavigation(): void;
+    SaveLocalState(): Promise<void>;
+    SelectCollectionsAppFilterOption<K extends keyof FilterOptionByIndex_t>(group: K, option: FilterOptionByIndex_t[K], value: boolean): Promise<void>;
+    SelectGameListView(param0: EGameListView, collectionId: string): void;
+    SelectGamepadCollectionsAppFilterOption<K extends keyof FilterOptionByIndex_t>(group: K, option: FilterOptionByIndex_t[K], value: boolean): Promise<void>;
+    SetCollectionEditorOpen(value: boolean): void;
+    SetCollectionRenameOpen(value: boolean): void;
+    SetGameListGroupedByCollection(value: boolean): void;
+    SetGameListGroupedBySharedLibrary(value: boolean): void;
+    SetGameListSelection(strCollectionId: string, nAppId: number): Promise<void>;
+    SetGameListSortedByRecent(value: boolean): void;
+    SetIsCollapsed(collectionId: string, value: boolean): void;
+    SetMultiSelectHooksForGameListSelection(): void;
+    SetRecentGamesFirstApp(appid: number): void;
+    SetSearchByTypePaneOpen(value: boolean): void;
+    SetSearchText(query: string): Promise<void>;
+    ShowCollectionViewWithAppTypes(...appTypes: EAppType[]): void;
+    ShowDurationControlDialog(callbacks: {
+        ConfirmContinue: () => void;
+        Cancel: () => void;
+    } | null): void;
+    ShowSharedAppsInLibrary(filter: CDynamicCollectionFilter, steamIds: number[]): void;
+    StartSearchByType(filter: CCollectionFilterBase): void;
+    toggleCollapsed(collectionId: string): void;
+    UpdateGameListSelection(): void;
+    get bIsGameListGroupedByCollection(): boolean;
+    get bIsGameListGroupedBySharedLibraries(): boolean;
+    get bIsGameListSortedByRecent(): boolean;
+    get clientSearchSuggestionIds(): Set<number>;
+    get collectionsAppFilter(): CCollectionFilterBase;
+    get collectionsAppFilterGamepad(): CCollectionFilterBase;
+    get currentAppFilter(): CCollectionFilterBase;
+    get currentCollectionID(): string;
+    get currentGameListSelection(): GameListSelection_t;
+    get currentUserSteamID(): CSteamID;
+    get isCollectionEditorOpen(): boolean;
+    get isCollectionRenameOpen(): boolean;
+    get searchSuggestionIds(): Set<number>;
+    get searchSuggestions(): CStoreItem[];
+    get selectedGameListView(): EGameListView;
+}
+export {};

package/dist/globals/stores/libraryuistore.js

@@ -0,0 +1,56 @@
+var EGameListView;
+(function (EGameListView) {
+    EGameListView[EGameListView["kNormal"] = 1] = "kNormal";
+    EGameListView[EGameListView["kSingleCollection"] = 10] = "kSingleCollection";
+    EGameListView[EGameListView["kSearchResults"] = 11] = "kSearchResults";
+})(EGameListView || (EGameListView = {}));
+export var EAppPropertiesSection;
+(function (EAppPropertiesSection) {
+    EAppPropertiesSection["General"] = "general";
+    EAppPropertiesSection["Compatibility"] = "compatibility";
+    EAppPropertiesSection["Updates"] = "updates";
+    EAppPropertiesSection["LocalFiles"] = "localfiles";
+    EAppPropertiesSection["Language"] = "language";
+    EAppPropertiesSection["Betas"] = "betas";
+    EAppPropertiesSection["Controller"] = "controller";
+    EAppPropertiesSection["Shortcut"] = "shortcut";
+    EAppPropertiesSection["Dlc"] = "dlc";
+    EAppPropertiesSection["Workshop"] = "workshop";
+    EAppPropertiesSection["Feedback"] = "feedback";
+})(EAppPropertiesSection || (EAppPropertiesSection = {}));
+export var EControllerConfiguratorSection;
+(function (EControllerConfiguratorSection) {
+    EControllerConfiguratorSection["Main"] = "Main";
+    EControllerConfiguratorSection["Summary"] = "Summary";
+    EControllerConfiguratorSection["Preview"] = "Preview";
+    EControllerConfiguratorSection["ActionSets"] = "ActionSets";
+    EControllerConfiguratorSection["Buttons"] = "Buttons";
+    EControllerConfiguratorSection["Triggers"] = "Triggers";
+    EControllerConfiguratorSection["Sticks"] = "Sticks";
+    EControllerConfiguratorSection["Touchpads"] = "Touchpads";
+    EControllerConfiguratorSection["Gyroscopes"] = "Gyroscopes";
+    EControllerConfiguratorSection["VirtualMenus"] = "VirtualMenus";
+    EControllerConfiguratorSection["ChooseBinding"] = "ChooseBinding";
+})(EControllerConfiguratorSection || (EControllerConfiguratorSection = {}));
+export var ESettingsZooSection;
+(function (ESettingsZooSection) {
+    ESettingsZooSection["Dropdowns"] = "Dropdowns";
+    ESettingsZooSection["Modals"] = "Modals";
+    ESettingsZooSection["Buttons"] = "Buttons";
+    ESettingsZooSection["Sliders"] = "Sliders";
+    ESettingsZooSection["Toggles"] = "Toggles";
+    ESettingsZooSection["OtherControls"] = "Misc";
+    ESettingsZooSection["Glyphs"] = "Glyphs";
+    ESettingsZooSection["SVG"] = "SVG";
+    ESettingsZooSection["Input"] = "Input";
+    ESettingsZooSection["Type"] = "Type";
+})(ESettingsZooSection || (ESettingsZooSection = {}));
+export var ESettingsZooDevSection;
+(function (ESettingsZooDevSection) {
+    ESettingsZooDevSection["DeveloperOptions"] = "DeveloperOptions";
+    ESettingsZooDevSection["VRDeveloperOptions"] = "VRDeveloperOptions";
+    ESettingsZooDevSection["AppSpotlight"] = "AppSpotlight";
+    ESettingsZooDevSection["PlayNext"] = "PlayNext";
+    ESettingsZooDevSection["Notifications"] = "Notifications";
+    ESettingsZooDevSection["Share"] = "Share";
+})(ESettingsZooDevSection || (ESettingsZooDevSection = {}));

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

@@ -0,0 +1,18 @@
+import type { ESteamRealm } from '../shared/enums';
+import type { CCallbackList } from '../shared/interfaces';
+import type { ELanguage } from '../steam-client/Settings';
+export interface CLocalizationManager {
+    m_cbkTokensChanged: CCallbackList;
+    m_mapFallbackTokens: Map<string, string>;
+    m_mapTokens: Map<string, string>;
+    m_rgLocalesToUse: string[];
+    AddTokens(dict: Record<string, string>, fallback?: Record<string, string>): void;
+    BLooksLikeToken(value: string): boolean;
+    GetELanguageFallbackOrder(realm?: ESteamRealm): ELanguage[];
+    GetPreferredLocales(): string[];
+    GetTokensChangedCallbackList(): CCallbackList;
+    LocalizeString(token: string, failSilently?: boolean): string;
+    LocalizeIfToken(token: string, failSilently?: boolean): string;
+    LocalizeStringFromFallback(token: string): string;
+    SetPreferredLocales(locales: string[]): void;
+}

package/dist/globals/stores/localizationmanager.js

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

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

@@ -0,0 +1,62 @@
+import type { Action, Location } from '../shared/history';
+import type { CCallbackList } from '../shared/interfaces';
+import type { BrowserViewHistory, BrowserViewPageSecurity, BrowserViewPopup } from '../steam-client/browser-view/BrowserViewPopup';
+type SteamBrowserTab_t = 'community' | 'store' | 'me';
+type SteamBrowserTabs_t = {
+    [key in SteamBrowserTab_t]: string;
+};
+export interface SteamBrowserHistoryState {
+    bExternal?: boolean;
+    strURL?: string;
+}
+interface TabbedBrowserWebPageRequest {
+    requestid: number;
+    strLastURL: string;
+    strTitle: string;
+    strURL: string;
+}
+interface CTabbedBrowserStore {
+    m_cbWebPageRequestsChanged: CCallbackList;
+    m_nActiveWebpageRequestID: number;
+    m_nWebPageRequestID: number;
+    m_rgWebPageRequests: TabbedBrowserWebPageRequest[];
+    AddWebPageRequest(url?: string, param1?: boolean): void;
+    GetWebPageRequestsChangedCallbackList(): CCallbackList;
+    RemoveAllRequests(): void;
+    RemoveWebPageRequest(requestId: number): boolean;
+    ReorderWebPageRequest(param0: number, param1: number): void;
+    Set(activeWebpageRequestId: number, webPageRequestId: number, webPageRequests: TabbedBrowserWebPageRequest[]): void;
+    UpdateWebPageRequest(requestId?: number, url?: string, title?: string): boolean;
+}
+export interface CMainWindowBrowserManager {
+    m_URL: string;
+    m_URLRequested: string;
+    m_bExpectImportantReplace: boolean;
+    m_bLoading: boolean;
+    m_bRouterChangeTroggeredBySync: boolean;
+    m_browser: BrowserViewPopup;
+    m_browserHistory: BrowserViewHistory;
+    m_history: any;
+    m_lastActiveTab: SteamBrowserTab_t;
+    m_lastActiveTabURLs: SteamBrowserTabs_t;
+    m_lastLocation: Location<SteamBrowserHistoryState>;
+    m_loadErrorCode: number | null;
+    m_loadErrorDesc: string | null;
+    m_loadErrorURL: string | null;
+    m_pageSecurity: BrowserViewPageSecurity | null;
+    m_rootTabURLs: SteamBrowserTabs_t;
+    m_strTitle: string;
+    m_tabbedBrowserStore: CTabbedBrowserStore;
+    m_tsWaitingForBrowserChange: number | undefined;
+    ActivateTab(tab: SteamBrowserTab_t): void;
+    BIsWaitingForHistoryCallback(): boolean;
+    GetLastActiveTab(): SteamBrowserTab_t;
+    GetTabForURL(url: string): SteamBrowserTab_t | 'ignore' | 'maintain';
+    LoadURL(url: string): void;
+    Reload(): void;
+    ShowURL(url: string, state: SteamBrowserHistoryState): void;
+    SyncWithNewBrowserHistory(entry: BrowserViewHistory): void;
+    SyncWithNewRouterEvent(location: Location<SteamBrowserHistoryState>, action: Action): void;
+    UpdateActiveTab(url: string): void;
+}
+export {};

package/dist/globals/stores/mainwindowbrowsermanager.js

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

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

@@ -0,0 +1,242 @@
+import type { ReactNode } from 'react';
+import type { ESteamUISound } from '../shared/enums';
+import type { CCallbackList } from '../shared/interfaces';
+import { EClientNotificationType } from '../steam-client/Notifications';
+import type { EParentalFeature } from '../steam-client/Parental';
+import type { EACState } from '../steam-client/system';
+export declare enum EBroadcastPermission {
+    k_EBroadcastPermissionDisabled = 0,
+    k_EBroadcastPermissionFriendsApprove = 1,
+    k_EBroadcastPermissionFriendsAllowed = 2,
+    k_EBroadcastPermissionPublic = 3,
+    k_EBroadcastPermissionSubscribers = 4
+}
+export declare enum ESteamNotificationSource {
+    Client = 0,
+    Server = 1
+}
+export declare enum ESteamNotificationAction {
+    New = 0,
+    Update = 1,
+    Remove = 2
+}
+interface SteamNotificationData {
+    bCritical: boolean;
+    body: string;
+    duration: number;
+    logo: ReactNode;
+    onClick: () => void;
+    playSound: boolean;
+    showNewIndicator: boolean;
+    showToast: boolean;
+    sound: ESteamUISound;
+    timestamp: Date;
+    title: string;
+}
+type RequiredProcessNotifArgs = Record<EClientNotificationType, Record<string, any>> & {
+    [EClientNotificationType.Invalid]: {};
+    [EClientNotificationType.DownloadComplete]: {};
+    [EClientNotificationType.FriendInvite]: {};
+    [EClientNotificationType.FriendInGame]: {};
+    [EClientNotificationType.FriendOnline]: {};
+    [EClientNotificationType.Achievement]: {
+        achieved(): boolean;
+    };
+    [EClientNotificationType.LowBattery]: {};
+    [EClientNotificationType.SystemUpdate]: {};
+    [EClientNotificationType.FriendMessage]: {};
+    [EClientNotificationType.GroupChatMessage]: {
+        tag(): string;
+    };
+    [EClientNotificationType.FriendInviteRollup]: {};
+    [EClientNotificationType.FamilySharingDeviceAuthorizationChanged]: {};
+    [EClientNotificationType.FamilySharingStopPlaying]: {};
+    [EClientNotificationType.FamilySharingLibraryAvailable]: {};
+    [EClientNotificationType.Screenshot]: {};
+    [EClientNotificationType.CloudSyncFailure]: {};
+    [EClientNotificationType.CloudSyncConflict]: {};
+    [EClientNotificationType.IncomingVoiceChat]: {};
+    [EClientNotificationType.ClaimSteamDeckRewards]: {};
+    [EClientNotificationType.GiftReceived]: {};
+    [EClientNotificationType.ItemAnnouncement]: {};
+    [EClientNotificationType.HardwareSurvey]: {};
+    [EClientNotificationType.LowDiskSpace]: {};
+    [EClientNotificationType.BatteryTemperature]: {};
+    [EClientNotificationType.DockUnsupportedFirmware]: {};
+    [EClientNotificationType.PeerContentUpload]: {};
+    [EClientNotificationType.CannotReadControllerGuideButton]: {};
+    [EClientNotificationType.Comment]: {};
+    [EClientNotificationType.Wishlist]: {};
+    [EClientNotificationType.TradeOffer]: {};
+    [EClientNotificationType.AsyncGame]: {};
+    [EClientNotificationType.General]: {};
+    [EClientNotificationType.HelpRequest]: {};
+    [EClientNotificationType.OverlaySplashScreen]: {};
+    [EClientNotificationType.BroadcastAvailableToWatch]: {};
+    [EClientNotificationType.TimedTrialRemaining]: {};
+    [EClientNotificationType.LoginRefresh]: {};
+    [EClientNotificationType.MajorSale]: {};
+    [EClientNotificationType.TimerExpired]: {};
+    [EClientNotificationType.ModeratorMsg]: {};
+    [EClientNotificationType.SteamInputActionSetChanged]: {};
+    [EClientNotificationType.RemoteClientConnection]: {};
+    [EClientNotificationType.RemoteClientStartStream]: {};
+    [EClientNotificationType.StreamingClientConnection]: {};
+    [EClientNotificationType.FamilyInvite]: {};
+    [EClientNotificationType.PlaytimeWarning]: {};
+    [EClientNotificationType.FamilyPurchaseRequest]: {};
+    [EClientNotificationType.FamilyPurchaseRequestResponse]: {};
+    [EClientNotificationType.ParentalFeatureRequest]: {};
+    [EClientNotificationType.ParentalPlaytimeRequest]: {};
+    [EClientNotificationType.GameRecordingError]: {};
+    [EClientNotificationType.ParentalFeatureResponse]: {};
+    [EClientNotificationType.ParentalPlaytimeResponse]: {};
+    [EClientNotificationType.RequestedGameAdded]: {};
+    [EClientNotificationType.ClipDownloaded]: {};
+    [EClientNotificationType.GameRecordingStart]: {};
+    [EClientNotificationType.GameRecordingStop]: {};
+    [EClientNotificationType.GameRecordingUserMarkerAdded]: {};
+    [EClientNotificationType.GameRecordingInstantClip]: {};
+};
+export interface SteamNotification<T extends EClientNotificationType = EClientNotificationType> {
+    bNewIndicator: boolean;
+    data: SteamNotificationData;
+    eSource: ESteamNotificationSource;
+    eType: T;
+    nToastDurationMS: number;
+    notificationID: number;
+    rtCreated: number;
+}
+export interface TrayNotification {
+    eType: EClientNotificationType;
+    notifications: SteamNotification[];
+}
+export interface NotificationTarget {
+    eFeature?: EParentalFeature;
+    fnNotificationResolved?: () => void;
+    fnShowModal?: () => void;
+    fnTray?: (target: NotificationTarget, notificationsInTray: TrayNotification[]) => void;
+    nRemoveFromTraySec?: number;
+    toastDurationMS?: number;
+    type: EClientNotificationType;
+}
+export interface CNotificationStore {
+    m_LastSystemUpdateNotification: Pick<SteamNotification, 'eType' | 'rtCreated'> | null;
+    m_bCheckBatteryAfterResume: boolean;
+    m_bShowClientItemAnnouncementToasts: boolean;
+    m_bShowedHighBatteryTempNotification: boolean;
+    m_bShowedLowBatteryTempNotification: boolean;
+    m_bShowedRefreshLogin: boolean;
+    m_bTestNotifications: boolean;
+    m_cbkCurrentToast: CCallbackList<[TrayNotification[]]>;
+    m_cbkNotificationTray: CCallbackList<[TrayNotification[]]>;
+    m_hPendingToastTimer: number;
+    m_hTrayRemoveTimer: number;
+    m_iLastBatteryLevelNotification: number;
+    m_mapAppOverlayToasts: Map<number, SteamNotification[]>;
+    m_mapToastLastShown: Map<number, Map<string, number>>;
+    m_nNextTestNotificationID: number;
+    m_nUnviewedNotifications: number;
+    m_rgContextsRenderingToasts: number[];
+    m_rgNotificationToasts: SteamNotification[];
+    m_rgNotificationTray: TrayNotification[];
+    m_rgPendingToasts: SteamNotification[];
+    m_rtNextTrayRemove: number;
+    m_setContextsRenderingToasts: Set<any>;
+    AddAppOverlayNotification(appId: number, notificationId: number, type: EClientNotificationType, param3: any, notificationResolvedCallback: () => void): void;
+    AddBroadcastAvailableToWatch(appId: number, permission: EBroadcastPermission): void;
+    AddOverlaySplashScreen(appId: number): void;
+    AddTimedTrialRemaining(appid: number, icon: string, offline: boolean, allowedSeconds: number, playedSeconds?: number): void;
+    AppOverlayRunning(appId: number, value: boolean): void;
+    BAnyContextRenderingToasts(): boolean;
+    BAnyToastDisplayAlone(toasts: SteamNotification[]): boolean;
+    BContextRenderingToasts(e: any): boolean;
+    BIsToastRateLimited(e: number, t: any, r: number): boolean;
+    BIsUserInGame(): boolean;
+    BNextToastDisplayAlone(appId: number): boolean;
+    BShowToast(e: any, t: any): boolean;
+    BSkipSystemUpdateNotification(type: EClientNotificationType): boolean;
+    ChooseSound(data: SteamNotificationData, t: any): any | null;
+    ClearAllToastNotifications(): void;
+    ClearRemoveFromTrayTimer(): void;
+    Dev_SendTestNotifications(): void;
+    DispatchNextToast(): void;
+    DoScreenshotNotification(screenshotHandle: number, description: string): void;
+    ExpireToast(toast: SteamNotification): void;
+    GetCurrentAppOverlayNotification(appId: number): SteamNotification;
+    GetCurrentToastNotification(): SteamNotification | null;
+    GetNotificationTargets(): Record<EClientNotificationType, SteamNotification>;
+    GetNotificationsInTray(): [CNotificationStore['m_rgNotificationTray'], CNotificationStore['m_cbkNotificationTray']];
+    IncomingVoiceChat(steamId: number, show: boolean): void;
+    LoadServerToastRequiredData(steamId: number): boolean;
+    MarkNotificationRead(notificationId: number): void;
+    NotifyClaimSteamDeckRewards(): void;
+    NotifyLowDiskSpace(folderIndex: number): void;
+    NotifyTimerExpired(appId: number): void;
+    OnBatteryLevelChange(flLevel: number, eACState: EACState, bHasBattery: boolean): void;
+    OnBatteryTemperatureChange(temperature: number): void;
+    OnNewNotificationReceived(notification: SteamNotification): void;
+    OnNotification(notificationIndex: number, type: EClientNotificationType, data: ArrayBuffer): void;
+    OnNotificationUpdateReceived(toast: SteamNotification, action: ESteamNotificationAction): void;
+    OnScreenshotStarted(): void;
+    PendingLoginRefresh(showedRefreshLogin: boolean): void;
+    PlayNotificationSound(toast: SteamNotification): void;
+    PopNextToastNotification(appId: number): SteamNotification;
+    ProcessNotification<T extends EClientNotificationType>(target: NotificationTarget, notification: SteamNotification<T> & RequiredProcessNotifArgs[T], action: ESteamNotificationAction): void;
+    RemoveFromToastsWhere(callback: (toast: SteamNotification) => void): void;
+    RemoveFromTrayWhere(callback: (toast: SteamNotification) => void): void;
+    RemoveScreenshotNotification(screenshotHandle: number): void;
+    RunDebugTestsWhenServicesReady(e: boolean): void;
+    ScheduleRemoveFromTray(delaySeconds: number): void;
+    SendPendingServerToasts(): void;
+    SetContextRenderingToast(context: any, add: boolean): void;
+    Viewed(): void;
+    TestAchievement(appId: number, showProgress: boolean): void;
+    TestAsyncGame(appId: number): void;
+    TestCloudSyncConflict(appId: number): void;
+    TestCloudSyncFailure(appId: number): void;
+    TestComment(): void;
+    TestDownloadComplete(appId: number): void;
+    TestFamilyInvite(steamId: number): void;
+    TestFamilyPurchaseRequest(steamId: number): void;
+    TestFamilyPurchaseRequestResponse(steamId: number): void;
+    TestFamilySharing(): void;
+    TestFriendIngame(gameName: string, steamId: number): void;
+    TestFriendInvite(steamId: number): void;
+    TestFriendInviteRollup(newInviteCount: number): void;
+    TestFriendMessage(steamId: number, messageBody: string): void;
+    TestFriendOnline(steamId: number): void;
+    TestGRE(): void;
+    TestGRUM(): void;
+    TestGameRecordingInstantClip(): void;
+    TestGeneralAnnouncement(): void;
+    TestGift(steamId: number): void;
+    TestGroupChatMention(steamId: number, messageBody: string): void;
+    TestGroupChatMessage(steamId: number, messageBody: string): void;
+    TestHardwareSurvey(): void;
+    TestHelpRequest(): void;
+    TestIncomingVoiceChat(): void;
+    TestItemAnnouncement(steamId: number): Promise<void>;
+    TestLowBatteryNotification(percentage: number): void;
+    TestMajorSale(): void;
+    TestModeratorMessage(): void;
+    TestParentalFeatureRequest(steamId: number): void;
+    TestParentalFeatureResponse(steamId: number): void;
+    TestParentalPlaytimeRequest(steamId: number): void;
+    TestParentalPlaytimeResponse(steamId: number): void;
+    TestPlaytestInvite(): void;
+    TestPlaytimeWarning(): void;
+    TestReadControllerGuide(): void;
+    TestRemoteClientConnection(): void;
+    TestRemoteClientStartStream(): void;
+    TestRequestedGameAdded(steamid64?: string): void;
+    TestScreenshot(): void;
+    TestSteamInputActionSetChanged(): void;
+    TestStreamingClientConnection(): void;
+    TestSystemUpdate(notificationType: 1 | 2): void;
+    TestTradeOffer(): void;
+    TestTradeReversal(): void;
+    TestUnsupportedDock(): void;
+    TestWishlist(appId: number): void;
+}
+export {};

package/dist/globals/stores/notificationstore.js

@@ -0,0 +1,20 @@
+import { EClientNotificationType } from '../steam-client/Notifications';
+export var EBroadcastPermission;
+(function (EBroadcastPermission) {
+    EBroadcastPermission[EBroadcastPermission["k_EBroadcastPermissionDisabled"] = 0] = "k_EBroadcastPermissionDisabled";
+    EBroadcastPermission[EBroadcastPermission["k_EBroadcastPermissionFriendsApprove"] = 1] = "k_EBroadcastPermissionFriendsApprove";
+    EBroadcastPermission[EBroadcastPermission["k_EBroadcastPermissionFriendsAllowed"] = 2] = "k_EBroadcastPermissionFriendsAllowed";
+    EBroadcastPermission[EBroadcastPermission["k_EBroadcastPermissionPublic"] = 3] = "k_EBroadcastPermissionPublic";
+    EBroadcastPermission[EBroadcastPermission["k_EBroadcastPermissionSubscribers"] = 4] = "k_EBroadcastPermissionSubscribers";
+})(EBroadcastPermission || (EBroadcastPermission = {}));
+export var ESteamNotificationSource;
+(function (ESteamNotificationSource) {
+    ESteamNotificationSource[ESteamNotificationSource["Client"] = 0] = "Client";
+    ESteamNotificationSource[ESteamNotificationSource["Server"] = 1] = "Server";
+})(ESteamNotificationSource || (ESteamNotificationSource = {}));
+export var ESteamNotificationAction;
+(function (ESteamNotificationAction) {
+    ESteamNotificationAction[ESteamNotificationAction["New"] = 0] = "New";
+    ESteamNotificationAction[ESteamNotificationAction["Update"] = 1] = "Update";
+    ESteamNotificationAction[ESteamNotificationAction["Remove"] = 2] = "Remove";
+})(ESteamNotificationAction || (ESteamNotificationAction = {}));