@decky/ui 4.15.1 → 4.16.1

package/src/globals/stores/settingsstore.ts

@@ -0,0 +1,134 @@
+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 enum ETextFilterSetting {
+  SteamLabOptedOut,
+  Enabled,
+  EnabledAllowProfanity,
+  Disabled,
+}
+
+export enum EUserReviewScorePreference {
+  Unset,
+  IncludeAll,
+  ExcludeBombs,
+}
+
+export enum EProvideDeckFeedbackPreference {
+  Unset,
+  Yes,
+  No,
+}
+
+/**
+ * @see https://github.com/SteamDatabase/SteamTracking/blob/master/Protobufs/steammessages_notifications.steamclient.proto#L58
+ */
+interface SteamNotificationPreference {
+  notification_targets: number;
+  notification_type: EClientNotificationType;
+}
+
+/**
+ * @see https://github.com/SteamDatabase/SteamTracking/blob/master/Protobufs/steammessages_base.proto#L342
+ */
+interface ContentDescriptor {
+  content_descriptorid: number;
+  timestamp_added: number;
+}
+
+/**
+ * @see https://github.com/SteamDatabase/SteamTracking/blob/master/Protobufs/steammessages_base.proto#L341
+ */
+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>;
+
+  /**
+   * @returns `true` if connected to Steam.
+   */
+  BIsConnectedToSteam(): boolean;
+
+  /**
+   * @returns a ProtoBuf message.
+   */
+  CommunityPreferencesToMessage(value: CommunityPreferences): any;
+
+  GetBatteryPreferences(): BatteryPreferences;
+
+  /**
+   * Gets a Steam client option as a `[value, setValue]` tuple.
+   */
+  // TODO(protobufs): ReturnType can go maybe
+  GetClientSetting<K extends keyof MsgClientSettings, V = ReturnType<MsgClientSettings[K]>>(
+    setting: K,
+  ): [V, (value: V) => void];
+
+  IsDeferred(value: string): boolean;
+  IsSteamInTournamentMode(): boolean;
+  // proto msgs
+  MergeCommunityPreferences(e: any, t: any): void;
+  // proto msgs
+  MergeNotificationPreferences(e: any): void;
+  // proto msgs
+  MergeStorePreferences(e: any, t: any): void;
+
+  /**
+   * Updates monitor info with the current data.
+   */
+  RefreshMonitorInfo(): void;
+
+  SetBatteryPreferences(value: BatteryPreferences): void;
+  SetCommunityPreferences(value: CommunityPreferences): void;
+  SetDeferred(value: string): void;
+  SetStorePreferences(value: StorePreferences): void;
+
+  /**
+   * Sets windowed mode for BPM.
+   */
+  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;
+}

package/src/globals/stores/steamuistore/gamepadbrowserview.ts

@@ -0,0 +1,172 @@
+import type { CCallbackList, SubscribableValue } from '../../shared';
+import type { BrowserViewHistory, BrowserViewPopup } from '../../steam-client/browser-view/BrowserViewPopup';
+import type { CFocusNavController } from '../focusnavcontroller';
+
+enum EGameInputSupportLevel {
+  PageUnloading,
+  Unknown,
+  None,
+  Basic,
+  Full,
+}
+
+interface ActionDescription {
+  /** @todo GamepadButton ? */
+  button: any;
+  descriptions: any;
+  /** @todo EFocusSource ? */
+  source: any;
+  support: EGameInputSupportLevel;
+}
+
+interface GamepadBrowserViewMessageDetails_t {
+  type: string;
+  data: {
+    /**
+     * {@link Event.type} property
+     */
+    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;
+
+  /**
+   * @returns an uninit function.
+   */
+  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;
+}

package/src/globals/stores/steamuistore/gamepaduiaudio.ts

@@ -0,0 +1,117 @@
+import type { ESteamUISound, UIMode, SubscribableValue, Unsubscribable } from '../../shared';
+import type { FocusChangeEvent } from '../../steam-client/system/UI';
+import type { CFocusNavigationContext } from '../../stores';
+
+/**
+ * Steam UI sound file names relative to `https://steamloopback.host/sounds`.
+ *
+ * Generated with:
+ * ```js
+ * fs.readdirSync(`${os.homedir()}/.steam/steamui/sounds`).map((e) => `'${e}'`).join('|');
+ * ```
+ */
+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;
+
+  /**
+   * Registers a function to be called when the audio file finishes playback.
+   *
+   * @param callback The function to be called on finish.
+   */
+  RegisterOnPlaybackFinished(callback: () => void): void;
+
+  /**
+   * Stops the audio file playback.
+   */
+  StopPlayback(): void;
+
+  get url(): string;
+}
+
+export declare class CGamepadUIAudioStore {
+  m_AudioPlaybackManager: CGamepadUIAudioPlaybackManager;
+  m_bCanPlaySound: boolean;
+  m_currentlyFocusedAppid: SubscribableValue<number>;
+  m_fnGetUIMode: () => UIMode;
+  /** {@link setTimeout} handle */
+  m_pendingSoundHandle: number | null;
+  m_pendingSoundType: ESteamUISound;
+
+  OnFocusChangeEvent(ev: FocusChangeEvent): void;
+
+  OnGamepadFocusChanged(e: number, t: any, r: any | undefined): void;
+
+  OnUnhandledButtonDownEvent(ev: GamepadEvent): void;
+
+  /**
+   * Like {@link PlayNavSound}, but using a URL path instead.
+   *
+   * @param url The URL path to play.
+   */
+  PlayAudioURL(sound: `/sounds/${NavAudioFile_t}`): CGamepadUIAudioPlaybackManager;
+
+  /**
+   * Plays a Steam UI sound.
+   *
+   * @param type The sound to play.
+   */
+  PlayNavSound(type: ESteamUISound): void;
+
+  PlayNavSoundInternal(type: ESteamUISound): void;
+
+  RegisterFocusNavContext(context: CFocusNavigationContext): Unsubscribable;
+
+  get AudioPlaybackManager(): CGamepadUIAudioPlaybackManager;
+}

package/src/globals/stores/steamuistore/index.ts

@@ -0,0 +1,217 @@
+import type { UIMode } 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';
+
+enum EAppDetailsDisplayMode {
+  SteamUI,
+  BasicUI,
+}
+
+enum ENavigationMode {
+  Digital,
+  Cursor,
+}
+
+export interface CSteamUIStore {
+  m_ConfiguratorWidth: number;
+  m_GamepadNavigationManager: CFocusNavController;
+  m_GamepadUIAudioStore: CGamepadUIAudioStore;
+  //m_LastLibraryTab: any;
+  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_mainInstancUIMode: UIMode;
+  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;
+
+  /**
+   * @returns `true` if any of the windows is focused.
+   */
+  BIsAnyWindowFocused(): boolean;
+
+  BIsOverlayPath(path: string): boolean;
+
+  /**
+   * @returns `true` if Steam is shutting down.
+   */
+  BIsShuttingDown(): boolean;
+
+  /**
+   * @returns `true` if provided app ID is the game you're currently streaming.
+   */
+  BIsStreamingGame(appid: number): boolean;
+
+  BIsStreamingRemotePlayTogether(): boolean;
+  BIsStreamingRemotePlayTogetherGame(appid: number): boolean;
+  BIsTransparentBackgroundPath(path: string): boolean;
+  BIsVROverlayApp(overview: SteamAppOverview): boolean;
+
+  /**
+   * @returns `true` if provided app is available only for VR.
+   */
+  BIsVrOnlyGame(overview: SteamAppOverview): boolean;
+
+  BRemotePlaySessionLocalClient(steam64Id: string): boolean;
+  CancelRefreshLogin(): void;
+  ClearSaleCache(): Promise<void>;
+  ClearShutdownFailure(): void;
+
+  /**
+   * If calling this to perform navigation, call it after {@link Navigate} to
+   * prevent a race condition in desktop BPM that hides the overlay
+   * unintentionally.
+   */
+  CloseSideMenus(): void;
+
+  DisableHomeAndQuickAccessButtons(): void;
+  EnableHomeAndQuickAccessButtons(): void;
+  ExcludedTitlesForPlatform(): number[];
+
+  /**
+   * @returns the currently focused window instance (for {@link Window} see {@link SteamUIWindowInstance.BrowserWindow}).
+   */
+  GetFocusedWindowInstance(): SteamUIWindowInstance;
+
+  GetLastLibraryTab(): {
+    collectionid?: string;
+    strActiveTab: string;
+  };
+  GetShowingLockScreen(): boolean;
+  GetShutdownState(): {
+    appid: number;
+    bAllowForceQuit: boolean;
+    bFailed: boolean;
+    eShutdownState: EShutdownStep;
+  };
+  GetWindowForRunningAppNavigation(): SteamUIWindowInstance;
+
+  /**
+   * Gets the overlay window instance for a provided PID.
+   *
+   * @param pid The "gameoverlayui" process PID.
+   */
+  GetWindowInstanceForPID(pid: number): SteamUIWindowInstance | undefined;
+
+  /**
+   * @returns `true` if there is at least 1 Steam app running.
+   */
+  IsAnyAppRunning(): boolean;
+
+  /**
+   * @returns `true` if the Steam console is enabled.
+   */
+  IsConsoleEnabled(): boolean;
+
+  IsDeckFactoryImage(): boolean;
+
+  /**
+   * @returns `true` if there is a desktop mode window open.
+   */
+  IsDesktopUIWindowActive(): boolean;
+
+  /**
+   * @returns `true` if there is a BPM window open.
+   */
+  IsGamepadUIWindowActive(): boolean;
+
+  /**
+   * Navigates to a provided React route.
+   *
+   * @param route React route to navigate to, e.g. `/library/app/440`.
+   * @param matchRoute If `true`, router won't navigate to said route if it
+   * doesn't look like one.
+   * @param replaceHistoryEntry
+   */
+  Navigate(route: string, matchRoute?: boolean, replaceHistoryEntry?: boolean): void;
+
+  /**
+   * Shows the controller layout preview.
+   */
+  NavigateToLayoutPreview(appid: number, instance?: SteamUIWindowInstance): void;
+
+  NavigateToRunningApp(e: boolean): void;
+
+  /**
+   * Opens the "Power" menu.
+   *
+   * @param parent Menu parent element.
+   * @param onCancel Function to call on pressing "Cancel".
+   */
+  OpenPowerMenu(parent: HTMLElement, onCancel: () => void): void;
+
+  PreserveNavigation(): void;
+  // empty lol
+  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 MainInstancUIMode(): UIMode;
+  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 * from "./gamepadbrowserview";
+export * from "./gamepaduiaudio";
+export * from "./menu";
+export * from "./window";