@decky/ui 4.15.1 → 4.16.1

package/src/globals/stores/notificationstore.ts

@@ -0,0 +1,298 @@
+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';
+
+// TODO(protobufs): generate
+export enum EBroadcastPermission {
+  k_EBroadcastPermissionDisabled,
+  k_EBroadcastPermissionFriendsApprove,
+  k_EBroadcastPermissionFriendsAllowed,
+  k_EBroadcastPermissionPublic,
+  k_EBroadcastPermissionSubscribers,
+}
+
+export enum ESteamNotificationSource {
+  Client,
+  Server,
+}
+
+// that's what I *guess* it is, no idea what this is
+export enum ESteamNotificationAction {
+  New,
+  Update,
+  Remove,
+}
+
+interface SteamNotificationData {
+  bCritical: boolean;
+  body: string;
+  /**
+   * In ms.
+   */
+  duration: number;
+  logo: ReactNode;
+  onClick: () => void;
+  // TODO: apparently can be a function too
+  playSound: boolean;
+  showNewIndicator: boolean;
+  showToast: boolean;
+  // TODO: apparently can be a function too
+  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;
+  /**
+   * UNIX timestamp.
+   */
+  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;
+}
+
+/**
+ * All the functions starting with `Test` may be used to test notifications.
+ */
+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[]>;
+  // second map:
+  // {"function(){return e(this,...t)}_function(){return e(this,...t)}" => 1760072931}
+  // ?????
+  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, // data: i.proto.deserializeBinary(o)
+    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;
+
+  /**
+   * @returns `true` if you are currently in a game.
+   */
+  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;
+  // wtf is this
+  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;
+  /**
+   * @param temperature in Celsius
+   */
+  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;
+
+  // #region Test functions
+  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>;
+  /**
+   * @param percentage from 0 to 1
+   */
+  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;
+  // #endregion
+}

package/src/globals/stores/popupmanager.ts

@@ -0,0 +1,352 @@
+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;
+  /**
+   * Date as a Unix timestamp.
+   */
+  last_used: number;
+  strRestoreDetails: string;
+}
+
+export interface PopupCreationOptions {
+  /**
+   * Initially hidden, make it appear with a `Show` method from return result.
+   */
+  bCreateHidden?: boolean;
+
+  /**
+   * @todo bHideMainWindowForPopouts
+   */
+  bModal?: boolean;
+
+  /**
+   * Document title.
+   *
+   * @todo This is a getter in {@link SteamPopupParameters}, but a normal
+   * property in {@link ContextMenuPositionOptions}, wtf (does this matter tho)
+   */
+  title?: string;
+}
+
+export interface SteamPopupParameters extends PopupCreationOptions {
+  availscreenheight: number;
+  availscreenwidth: number;
+  /**
+   * Value of `SteamClient.Window.SetHideOnClose`.
+   */
+  bHideOnClose: boolean;
+  bNoFocusOnShow: boolean;
+  /**
+   * @todo saw in js, but is it there ?
+   */
+  bNoInitialShow: boolean;
+  bPinned: boolean;
+  /**
+   * Popup's `<body>` class.
+   */
+  body_class: string;
+  browserType: EBrowserType;
+  /**
+   * Popup is centered on this window.
+   */
+  center_on_window: Window;
+  dimensions: {
+    height?: number;
+    left?: number;
+    top?: number;
+    width?: number;
+  };
+  /**
+   * @see {@link EPopupCreationFlags}
+   */
+  eCreationFlags: number;
+  /**
+   * Popup `<html>` class.
+   */
+  html_class: string;
+  /**
+   * @todo unused ? maybe used with {@link bModal} ?
+   */
+  hwndParent: number;
+  /**
+   * Popup minimum height.
+   */
+  minHeight: number;
+  /**
+   * Popup minimum width.
+   */
+  minWidth: number;
+  /**
+   * Parent browser ID.
+   */
+  parent_container_popup_id: number;
+  /**
+   * Root element class.
+   */
+  popup_class: string;
+  replace_existing_popup: boolean;
+  strRestoreDetails: string;
+  strUserAgent: string;
+  strVROverlayKey: string;
+  /**
+   * These parameters are interpreted by the Steam process to open popups
+   * in the Steam overlay or SteamVR dashboard instead of on the desktop.
+   */
+  target_browser: BrowserContext;
+  /**
+   * Internal popup name.
+   */
+  m_strName: string;
+  /**
+   * Document title.
+   */
+  m_strTitle: string;
+  /**
+   * Parent browser ID.
+   */
+  window_opener_id: number;
+}
+
+/**
+ * Helper to track when all links for a newly created popup have loaded.
+ * Supports CPopup replacement too.
+ */
+export interface CRenderWhenLinksReady {
+  m_fnRender: () => void;
+  m_rgLoadingLinks: Node[];
+
+  AddLink(link: Node, checkIfLoaded: boolean): void;
+  SetTarget(renderCallback: () => void): void;
+}
+
+export interface SteamPopup {
+  /**
+   * `true` if the popup will not be shown initially.
+   */
+  m_bCreateHidden: boolean;
+  /**
+   * `true` if created.
+   */
+  m_bCreated: boolean;
+  /**
+   * `true` if focused.
+   */
+  m_bFocused: boolean;
+  m_callbacks: {
+    onLoad(e: any, t: any): any;
+    onResize(t: any, r: any, i: any): any;
+    updateParamsBeforeShow(...args: any[]): any;
+  };
+  /**
+   * Root element.
+   */
+  m_element: HTMLElement;
+  m_fnReadyToRender(...args: any[]): any;
+  m_onCreateRender: any;
+  m_popup: Window;
+  m_renderWhenReady: CRenderWhenLinksReady;
+  m_rgParams: Partial<SteamPopupParameters>;
+  /**
+   * Popup (internal) name.
+   */
+  m_strName: string;
+  /**
+   * Document title.
+   */
+  m_strTitle: string;
+
+  /**
+   * @returns `true` if the popup is closed.
+   */
+  BIsClosed(): boolean;
+
+  /**
+   * @returns `true` if the popup is focused.
+   */
+  BIsFocused(): boolean;
+
+  /**
+   * @returns `true` if the popup is usable.
+   */
+  BIsValid(): boolean;
+
+  /**
+   * @returns `true` if not closed and not minimized.
+   */
+  BIsVisible(): boolean;
+
+  /**
+   * Closes the popup.
+   */
+  Close(): void;
+
+  /**
+   * Focuses the popup.
+   */
+  Focus(eForceOS?: EWindowBringToFront): void;
+
+  /**
+   * @returns the internal name.
+   */
+  GetName(): string;
+
+  /**
+   * @returns the popup's restore details.
+   */
+  GetWindowRestoreDetails(): Promise<string>;
+
+  /**
+   * @returns `true` if the window is maximized.
+   */
+  IsMaximized(): Promise<boolean>;
+
+  /**
+   * @returns `true` if the window is minimized.
+   */
+  IsMinimized(): Promise<boolean>;
+
+  // #region Window events, not always available
+  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;
+  // #endregion
+
+  /**
+   * Closes the popup and releases it from memory, beyond that the popup is
+   * unusable.
+   */
+  ReleasePopup(): void;
+
+  /**
+   * Removes all event listeners attached to the popup window.
+   */
+  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;
+
+  /**
+   * Adds a callback to dispatch on popup creation.
+   */
+  AddPopupCreatedCallback(callback: PopupCallback_t): Unsubscribable;
+
+  /**
+   * Adds a callback to dispatch on popup destruction.
+   */
+  AddPopupDestroyedCallback(callback: PopupCallback_t): Unsubscribable;
+
+  /**
+   * Adds a callback to dispatch on Steam shutdown.
+   */
+  AddShutdownCallback(callback: () => void): Unsubscribable;
+
+  /**
+   * Adds a popup and dispatches all the callbacks.
+   */
+  AddTrackedPopup(popup: SteamPopup): void;
+
+  /**
+   * @returns `true` if one of the context menu *popups* is focused.
+   */
+  BAnyMenuHasFocus(): boolean;
+
+  /**
+   * @returns `true` if one of the windows is focused.
+   */
+  BAnyPopupHasFocus(): boolean;
+
+  /**
+   * @returns `true` if Steam is about to shut down.
+   */
+  BShuttingDown(): boolean;
+
+  /**
+   * Clears saved restore details from {@link m_mapRestoreDetails}.
+   */
+  ClearSavedDimensionStore(): void;
+
+  /**
+   * Closes all popups owned by provided browser.
+   */
+  ClosePopupsOwnedByBrowser(browser: BrowserContext): void;
+
+  /**
+   * @returns the popup for the specified popup name.
+   */
+  GetExistingPopup(popupName: string): SteamPopup;
+
+  /**
+   * @returns the key used for usage in {@link localStorage}. Saved on a
+   * per-account basis.
+   */
+  GetLocalStorageKey(): string;
+
+  /**
+   * @returns the popup for the specified window.
+   */
+  GetPopupForWindow(window: Window): SteamPopup;
+
+  /**
+   * @returns a list of current popups.
+   */
+  GetPopups(): SteamPopup[];
+
+  /**
+   * @returns restore details for the specified window.
+   */
+  GetRestoreDetails(windowName: string): string;
+
+  /**
+   * Loads saved restore details from {@link localStorage}.
+   */
+  LoadSavedDimensionStore(): void;
+
+  /**
+   * Deletes a popup.
+   */
+  RemoveTrackedPopup(popup: SteamPopup): void;
+
+  /**
+   * Saves restore details in {@link localStorage}.
+   */
+  SaveSavedDimensionStore(): void;
+
+  /**
+   * Sets the provided account ID for later usage with restore details.
+   *
+   * @param accountId SteamID 3
+   */
+  SetCurrentLoggedInAccountID(accountId: number): void;
+
+  /**
+   * Sets restore details for the specified popup.
+   */
+  SetRestoreDetails(popupName: string, restoreDetails: string, expires: boolean): void;
+}

package/src/globals/stores/securitystore.ts

@@ -0,0 +1,36 @@
+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;
+}