@decky/ui 4.15.1 → 4.16.0

package/src/globals/stores/friendstore/shared.ts

@@ -0,0 +1,318 @@
+import type { BrowserContext, CSteamID } from '../../shared';
+import type { CChat } from './friendchat';
+
+export enum EClientPersonaStateFlag {
+  k_EClientPersonaStateFlagStatus = 1 << 0,
+  k_EClientPersonaStateFlagPlayerName = 1 << 1,
+  k_EClientPersonaStateFlagQueryPort = 1 << 2,
+  k_EClientPersonaStateFlagSourceID = 1 << 3,
+  k_EClientPersonaStateFlagPresence = 1 << 4,
+  k_EClientPersonaStateFlagLastSeen = 1 << 5,
+  k_EClientPersonaStateFlagUserClanRank = 1 << 6,
+  k_EClientPersonaStateGameExtraInfo = 1 << 7,
+  k_EClientPersonaStateGameDataBlob = 1 << 8,
+  k_EClientPersonaStateFlagClanData = 1 << 9,
+  k_EClientPersonaStateFlagFacebook = 1 << 10,
+  k_EClientPersonaStateFlagRichPresence = 1 << 11,
+  k_EClientPersonaStateFlagBroadcast = 1 << 12,
+  k_EClientPersonaStateFlagWatching = 1 << 13,
+}
+
+export enum EFriendRelationship {
+  None,
+  Blocked,
+  RequestRecipient,
+  Friend,
+  RequestInitiator,
+  Ignored,
+  IgnoredFriend,
+  Suggested_DEPRECATED,
+  Max,
+}
+
+export enum EPersonaState {
+  Offline,
+  Online,
+  Busy,
+  Away,
+  Snooze,
+  LookingToTrade,
+  LookingToPlay,
+  Invisible,
+  Max,
+}
+
+// TODO(protobufs): generate
+declare class CPlayer_GetProfileItemsEquipped_Response {}
+
+declare class CPersonaStateImpl {
+  m_bAvatarPending: boolean;
+  m_bCommunityBanned: boolean;
+  m_bInitialized: boolean;
+  m_bNameInitialized: boolean;
+  m_bOnSteamDeck: boolean;
+  m_bPlayerNamePending: boolean;
+  m_bStatusInitialized: boolean;
+  m_broadcastAccountId: number | undefined;
+  m_broadcastAppId: number | undefined;
+  m_broadcastId: number | undefined;
+  m_broadcastViewerCount: number | undefined;
+  m_ePersonaState: EPersonaState;
+  m_game_lobby_id: string;
+  m_gameid: string;
+  m_mapRichPresence: Map<string, string>;
+  m_rtLastSeenOnline: number;
+  m_steamid: CSteamID;
+
+  /**
+   * @returns `true` if the user has set an avatar.
+   */
+  BHasAvatarSet(): boolean;
+
+  /**
+   * @returns `true` if app info is ready.
+   * @see {@link CAppInfoStore}
+   */
+  BIsAppInfoReady(): boolean;
+
+  /**
+   * @returns the user's SteamID3.
+   */
+  GetAccountID(): number;
+
+  /**
+   * @returns the user's community profile URL.
+   */
+  GetCommunityProfileURL(): string;
+
+  /**
+   * @returns the user's currently playing game's name.
+   */
+  GetCurrentGameName(): string;
+
+  /**
+   * @returns the user's currently playing game's icon URL.
+   */
+  GetCurrentGameIconURL(): string;
+
+  HasCurrentGameRichPresence(): boolean;
+
+  HasRichPresenceForViewGameInfo(): boolean;
+
+  GetCurrentGameRichPresence(): string;
+
+  /**
+   * @returns the user's currently playing game's status, e.g.
+   */
+  GetCurrentGameStatus(): string;
+
+  /**
+   * @returns the seconds at which rate the user's status will be updated.
+   */
+  GetOfflineStatusUpdateRate(): number;
+
+  /**
+   * @returns a localized string for offline time, e.g. "Last online 5 years
+   * ago".
+   */
+  GetOfflineStatusTime(): string;
+
+  /**
+   * @returns the localized online status, but still "Online" if in game.
+   */
+  GetLocalizedOnlineStatus(): string;
+
+  HasStateFlag(flag: EClientPersonaStateFlag): boolean;
+
+  /**
+   * @returns `true` if the user is currently using a Steam Deck.
+   */
+  IsOnSteamDeck(): boolean;
+
+  get avatar_url(): string;
+  get avatar_url_full(): string;
+  get avatar_url_medium(): string;
+  get connect_string(): string | undefined;
+  get has_joinable_game_flag(): boolean;
+  get has_public_party_beacon(): boolean;
+  get has_server_ip(): boolean;
+  get is_awayOrSnooze(): boolean;
+  get is_golden(): boolean;
+  get is_in_joinable_game(): boolean;
+  get is_in_nonsteam_game(): boolean;
+  get is_in_valid_lobby(): boolean;
+  get is_ingame(): boolean;
+  get is_online(): boolean;
+  get is_watchingbroadcast(): boolean;
+  // UNIX timestamp
+  get last_seen_online(): number;
+  get online_state(): 'in-game' | 'offline' | 'online' | 'watchingbroadcast';
+  get player_group(): string;
+  get player_group_size(): number;
+}
+
+interface CommunityData {
+  avatar_url: string;
+  in_game: {
+    name: string;
+    is_non_steam: boolean;
+    logo: string;
+    rich_presence: string;
+  };
+  level: number;
+  level_class: string;
+  persona_name: string;
+  m_rtLastLoad: number;
+
+  /**
+   * Loads community data if not already.
+   */
+  EnsureCommunityDataLoaded(): void;
+
+  /**
+   * Reloads community data.
+   */
+  Reload(): void;
+}
+
+interface MiniProfileData {
+  m_accountid: number;
+  m_bLoadingData: boolean;
+  m_communityData: CommunityData | undefined;
+  m_nAppIDLastSeenPlaying: number;
+  m_persona: CPersonaStateImpl;
+  m_strAccountName: string;
+  m_strAvatarHash: string;
+  m_strBroadcastTitle: string | undefined;
+  m_strGameExtraInfo: string;
+  m_strPlayerName: string;
+  m_strProfileURL: string | undefined;
+  m_unGamePlayedAppID: number;
+  m_unGameServerIP: number;
+  m_unGameServerPort: number;
+  m_unPersonaStateFlags: number;
+}
+
+export interface PerFriendNotificationSettings {
+  Notifications_SendMobile: number;
+  Notifications_ShowInGame: number;
+  Notifications_ShowMessage: number;
+  Notifications_ShowOnline: number;
+  Sounds_PlayInGame: number;
+  Sounds_PlayMessage: number;
+  Sounds_PlayOnline: number;
+}
+
+export declare class CPlayer {
+  m_NotificationSettings: PerFriendNotificationSettings;
+  m_bLoadedEquippedProfileItems: boolean;
+  m_bPersonaNameHistoryLoaded: boolean;
+  m_bPersonaStateLoadRequested: boolean;
+  m_bRequestedEquippedProfileItems: boolean;
+  m_dtLastSeenPlaying: Date | undefined;
+  m_eFriendRelationship: EFriendRelationship;
+  m_equippedProfileItems: CPlayer_GetProfileItemsEquipped_Response;
+  m_miniProfileDataLoader: MiniProfileData | undefined;
+  m_rgPersonaNameHistory: string[];
+  m_strGameNameNormalized: string | undefined;
+  m_strNickname: string | undefined;
+  m_strPlayerNameNormalized: string | undefined;
+  m_strPlayerNicknameNormalized: string | undefined;
+  m_tsLastPersonaStateUpdate: number;
+  m_unAccountID: number;
+
+  BHaveReceivedPersonaUpdateSince(timestamp: number): boolean;
+
+  BLoadedEquippedItems(): boolean;
+
+  BMatchesSearchString(s: string, param1: boolean): boolean;
+
+  BPlayInGameSound(): boolean;
+
+  BPlayMessageSound(): boolean;
+
+  BPlayOnlineSound(): boolean;
+
+  BShowInGameNotification(): boolean;
+
+  BShowMessageNotification(): boolean;
+
+  BShowOnlineNotification(): boolean;
+
+  BWasRecentlyPlayingAppID(appid: number, seconds: number): boolean;
+
+  ClearStateOnDisconnect(): void;
+
+  /**
+   * @returns the broadcast's title or localized string if title is not set or
+   * `null` if not broadcasting.
+   */
+  GetBroadcastDescription(): string | null;
+
+  /**
+   * @returns the community profile URL.
+   */
+  GetCommunityProfileURL(): string;
+
+  GetEquippedProfileItems(): CPlayer_GetProfileItemsEquipped_Response;
+
+  LoadAndSetGoldenProfileFrame(): Promise<void>;
+
+  LoadEquippedProfileItems(e: boolean): Promise<void>;
+
+  LoadIfNecessary(): void;
+
+  /**
+   * Matches a provided string against the user's nickname.
+   *
+   * @param s The string to match.
+   */
+  MatchSearchString(s: string): {
+    bFullMatch: boolean;
+    iOffset: number;
+    match: number;
+  };
+
+  /**
+   * Opens the chat dialog.
+   */
+  OpenChatDialog(browser: BrowserContext): CChat;
+
+  SetLastSeenPlaying(appid: number): void;
+
+  SetPersonaStateUpdated(): void;
+
+  /**
+   * @returns `true` if app info is ready.
+   * @see {@link CAppInfoStore}
+   */
+  is_appinfo_ready(): boolean;
+
+  get accountid(): number;
+  get current_game_icon_url(): string;
+  get current_game_name(): string;
+  get current_game_rich_presence(): string;
+  get display_name(): string;
+  get efriendrelationship(): EFriendRelationship;
+  get has_nickname(): boolean;
+  get has_secondary_display_name(): boolean;
+  get is_blocked(): boolean;
+  get is_display_name_nickname(): boolean;
+  get is_friend(): boolean;
+  get is_ready(): boolean;
+  get localized_online_status(): string;
+  get miniProfileData(): MiniProfileData;
+  get mutable_persona(): CPersonaStateImpl;
+  // undefined until set, just use display_name
+  get nickname(): string | undefined;
+  set nickname(s: string);
+  get notification_settings(): PerFriendNotificationSettings;
+  get persona(): CPersonaStateImpl;
+  get persona_name_history(): string[];
+  get persona_name_history_loaded(): boolean;
+  get primary_display_name(): string;
+  get secondary_display_name(): string;
+  get showing_secondary_display_name(): boolean;
+  get steamid(): CSteamID;
+  get steamid64(): string;
+}

package/src/globals/stores/gamerecordingstore.ts

@@ -0,0 +1,367 @@
+import type { CSteamID } from '../shared';
+import type { CBaseProtoBufMsg, CScheduledFunc } from '../shared/interfaces';
+import type { EUCMFilePrivacyState } from '../steam-client/Screenshots';
+import type { EExportCodec } from '../steam-client/Settings';
+import type { EResult } from '../steam-client/shared';
+
+// #region TODO(protobufs): generate
+interface CGameRecording_ExportClip_Settings {
+  bitrate_kbps?: number;
+  width?: number;
+  height?: number;
+  frames_per_second?: number;
+  codec?: EExportCodec;
+}
+
+interface CGameRecordingTimelineEvent {
+  game_id: string;
+  rt_created: number;
+  possible_clip: number;
+  timeline_id: string;
+  entry_id: string;
+  timeline_offset_ms: string;
+  duration_ms: string;
+  marker_icon: string;
+  marker_title: string;
+  user_marker: boolean;
+}
+// #endregion
+
+export interface PlaybackDefinition_t {
+  m_nDurationMS: number;
+  m_nOffsetMS: number;
+  m_nTimelineStartMS: number;
+  m_strEntryID: string;
+  m_strRecordingID: string;
+  m_strTimelineID: string;
+}
+
+interface RunningTimeline_t {
+  m_globalStartMS: number;
+  m_metadata: {
+    date_recorded: number;
+    duration_ms: string;
+    game_id: string;
+    recordings: any[];
+    timeline_id: string;
+  };
+  m_nPerfCounterOffsetMS: number;
+  m_perfCounterStart: number;
+  m_runningRecording: any;
+}
+
+interface TimelineData_t {
+  m_rgEntries: any[];
+  m_rgGameModeChanges: any[];
+  m_rgPhases: any[];
+  m_rgStateDescriptions: any[];
+  m_strState: string;
+}
+
+interface TimelineLoader {
+  m_bInitialized: boolean;
+  m_clipID: string;
+  m_fnTimelineURLBuilder: (e: string) => string;
+  m_gameID: string;
+  m_mapRunningTimelines: Map<string, RunningTimeline_t>;
+  m_mapTimelineData: Map<string, TimelineData_t>;
+  m_rgListeners: any[];
+  m_rgTimelineMetadata: any[];
+  m_schUpdateRunning: CScheduledFunc;
+  m_ulFirstTimelineOffsetMS: number;
+
+  AddEventListener(e: any): any;
+  AddEventToTimeline(e: any, t: any, r: any, n: any, i: any, a: any, s: any, o: any): any;
+  AddRunningTimeline(e: any, t: any, r: any): any;
+  AddRunningTimelineEntry(e: any): any;
+  AddUserMarker(e: any, t: any, r: any, n: any): any;
+  AdvanceEntriesIndex(e: any): any;
+  AdvanceGameModeIndex(e: any): any;
+  AdvanceIterator(e: any, t: any): any;
+  BInitialized(): any;
+  BIsTimelineRunning(e: any): any;
+  BRecordingHasZeroOffset(e: any): any;
+  ClampGlobalRangeToTimeline(e: any, t: any, r: any): any;
+  ConvertGlobaOffsetToRecordingAndRelativeOffset(e: any): any;
+  ConvertRecordingOffsetToGlobalOffset(e: any, t: any, r: any): any;
+  ConvertRecordingTimeMStoPreTrimTimeMS(e: any, t: any): any;
+  CreateGlobalRangeForTimeline(e: any, t: any, r: any, n: any): any;
+  CreateTimelineIterator(e: any, t: any): any;
+  FindRangeEventsAtGlobalMS(e: any): any;
+  FindRecordingAndOffsetForEntry(e: any): Promise<any>;
+  FindTimelineAtOffset(e: any, t: any): any;
+  FireEvent(e: any, ...t: any): any;
+  GenerateClipNameFromTimeline(e: any, t: any, r: any, n: any): Promise<any>;
+  GenerateNamePartsFromTimeline(e: any, t: any, r: any, n: any): Promise<any>;
+  GetClipID(): any;
+  GetClosestNextEntryInGlobalTimeline(e: any): any;
+  GetClosestNextEntryInTimeline(e: any, t: any): any;
+  GetClosestNextRecordingInGlobalTimeline(e: any): any;
+  GetClosestPreviousEntryInGlobalTimeline(e: any): any;
+  GetClosestPreviousEntryInTimeline(e: any, t: any): any;
+  GetClosestPreviousRecordingInGlobalTimeline(e: any): any;
+  GetEndOfRecordingsMS(): any;
+  GetFirstRecording(): any;
+  GetFirstRecordingOfLastTimelineSession(): any;
+  GetGameID(): any;
+  GetGlobalOffsetDataForTimeline(e: any, t: any): any;
+  GetGlobalTimelineEndMS(): any;
+  GetIteratorGameMode(e: any): any;
+  GetIteratorTimelineState(e: any): any;
+  GetNextRecording(e: any): any;
+  GetRunningTimelineDurationMS(e: any): any;
+  GetRunningTimelineForRecording(e: any, t: any): any;
+  GetStateDescriptionAtGlobalMS(e: any): any;
+  GetTimelineData(e: any): any;
+  GetTimelineDataOrStartLoad(e: any): any;
+  GetTimelineDateMS(e: any, t: any): any;
+  GetTimelineMetadata(e: any): any;
+  GetTimelineMetadataIndex(e: any): any;
+  GetTimelineOffsetFromGlobal(e: any, t: any): any;
+  GetTimelineStartBeforeGlobalZeroMS(e: any): any;
+  GetTimelines(): any;
+  GetTotalRecordingDuration(): any;
+  HasIteratorReachedEnd(e: any): any;
+  InsertEntryIntoTimelineSorted(e: any, t: any): any;
+  IsActiveRecording(e: any): any;
+  IsActiveTimeline(e: any): any;
+  LoadTimelineData(e: any): Promise<any>;
+  LoadTimelinesForBackgroundVideo(e: any): Promise<any>;
+  LoadTimelinesForClip(e: any): Promise<any>;
+  LoadTimelinesForSharedClip(e: any): any;
+  LoadTimelinesForTestClip(e: any, t: any, r: any, n: any): any;
+  LoadTimelinesForTestGame(e: any, t: any): any;
+  MakeRelativeToTimelineEndIfActive(e: any, t: any): any;
+  ProcessTimelineEntries(e: any): any;
+  RecordingSessionChanged(e: any): any;
+  RemoveTimelineEvent(e: any, t: any): any;
+  RemoveUserMarker(e: any, t: any): any;
+  RunningTimelineStopped(e: any, t: any): any;
+  SetPreloadedTimelines(e: any, t: any, r: any, n: any, i: any): any;
+  SetTimelineData(e: any, t: any): any;
+  TimelineDeleted(e: any): any;
+  UpdateTimelineMetadata(e: any): any;
+  UpdateUserMarker(e: any, t: any, r: any): any;
+}
+
+interface CActiveTimeline {
+  loader: TimelineLoader;
+  release(): void;
+}
+
+declare class CTimelineEntry {}
+
+declare class CTimelineLoader {
+  loader: TimelineLoader;
+  nRefCount: number;
+}
+
+export interface ClipSummary_t {
+  clip_id: string;
+  date_clipped: number;
+  date_recorded: number;
+  duration_ms: string;
+  file_size: string;
+  game_id: string;
+  start_timeline_id: string;
+  start_offset_ms: string;
+  temporary: boolean;
+  thumbnail_height: number;
+  thumbnail_url: string;
+  thumbnail_width: number;
+}
+
+interface ClipExportProgress_t {
+  exportPath: string;
+  /** 0 - 1 in percentage */
+  progress: number;
+  resultStatus: EResult;
+}
+
+/**
+ * @see CGameRecording_GetAppsWithBackgroundVideo_Response
+ */
+interface AppWithTimeline_t {
+  file_size: string;
+  game_id: string;
+  is_active: boolean;
+  most_recent_start_time: number;
+  recording_type: number;
+  timeline_duration_seconds: number;
+  video_duration_seconds: number;
+}
+
+export declare class CGameRecordingStore {
+  m_bClipLoadingTriggered: boolean;
+  m_bEnoughDiskSpace: boolean;
+  m_bLoadingAppsWithBackgroundVideo: boolean;
+  m_bLoadingClips: boolean;
+  m_clipExportProgress: Map<string, ClipExportProgress_t>;
+  m_clips: Map<string, ClipSummary_t>;
+  m_clipsGroupByGame: Map<string, ClipSummary_t[]>;
+  m_currentlyExportingClip: string | undefined;
+  m_fnGetAchievementInfo: (
+    appid: number,
+    id: string,
+  ) => {
+    description: string;
+    iconURL: string;
+    name: string;
+  };
+  m_mapActiveTimelines: Map<string, CActiveTimeline>;
+  m_mapManualRecordingCallbacks: Map<string, any>;
+  m_mapSharedClipLoaders: Map<string, TimelineLoader>;
+  m_mapTimelineLoaders: Map<string, CTimelineLoader>;
+  m_recordingState: { m_gameID: string } | null;
+  m_rgAppsWithTimelines: AppWithTimeline_t[];
+  m_strLastClipID: string | undefined;
+  m_transport: any;
+
+  /**
+   * @returns `true` if not enough space on disk for clips.
+   */
+  BEnoughDiskSpace(): boolean;
+
+  BLoadingAppsWithBackgroundVideo(): boolean;
+
+  /**
+   * @returns `true` if clips are loading.
+   */
+  BLoadingClips(): boolean;
+
+  /**
+   * Forces a check for disk space.
+   */
+  CheckEnoughDiskSpace(): Promise<void>;
+
+  CreateUserTimelineMarkers(
+    game_id: string,
+    clip_id: string,
+    entry: CTimelineEntry,
+  ): Promise<{ eResult: EResult; entry_id: string }>;
+
+  /**
+   * Deletes a local clip.
+   */
+  DeleteClip(clip_id: string): Promise<EResult>;
+
+  ExportClip(
+    clip_id: string,
+    export_mp4_path: string,
+    settings: CGameRecording_ExportClip_Settings,
+    use_unique_filename: boolean,
+  ): Promise<EResult>;
+
+  /**
+   * @param appid App ID of the game to get info for.
+   * @param id Example: `"TF_BURN_PLAYERSINMINIMUMTIME"` for Team Fortress 2.
+   */
+  GetAchievementInfo(
+    appid: number,
+    id: string,
+  ): {
+    description: string;
+    iconURL: string;
+    name: string;
+  };
+
+  GetAppsWithBackgroundVideo(): AppWithTimeline_t[];
+
+  /**
+   * @returns the available disk space in bytes.
+   */
+  GetAvailableDiskSpace(): Promise<number>;
+
+  /**
+   * @returns the clip's title or the localized recorded date.
+   */
+  GetBestClipTitle(clip_id: string): string;
+
+  /**
+   * @returns the clip's export progress or `undefined` if not exporting(-ed).
+   */
+  GetClipExportProgress(clipID: string): ClipExportProgress_t | undefined;
+
+  /**
+   * @returns all clip IDs for a specified game.
+   */
+  GetClipIDs(gameid: string): string[];
+
+  /**
+   * @returns clips for the valid clip IDs.
+   */
+  GetClipSummaries(clipIDs: string[]): ClipSummary_t[];
+
+  /**
+   * @returns all clips for a provided game or `null` if none.
+   */
+  GetClipSummariesForGame(gameid: string): ClipSummary_t[] | null;
+
+  /**
+   * @returns a clip from a provided clip ID.
+   */
+  GetClipSummary(clipID: string): ClipSummary_t;
+
+  /**
+   * @returns the current exporting clip's ID or `null` if not exporting.
+   */
+  GetCurrentExportingClip(): string | null;
+
+  /**
+   * @returns the last clip.
+   */
+  GetLastClip(): ClipSummary_t | undefined;
+
+  GetRecordingHighlights(gameid: string, createdAfter?: number): Promise<CGameRecordingTimelineEvent[]>;
+  GetRecordingState(): this['m_recordingState'];
+  GetTimelineLoaderForClip(clip_id: string): CTimelineLoader;
+  GetTimelineLoaderForGame(gameid: string): CTimelineLoader;
+  GetTimelineLoaderForSharedClip(clip: ClipSummary_t): CTimelineLoader;
+  GetTotalDiskSpaceUsage(path: string, t: boolean): Promise<number>;
+  InternalAddClipSummary(clip: ClipSummary_t): void;
+  LazyLoadClips(): Promise<void>;
+  LoadAppsWithBackgroundVideo(): Promise<void>;
+  LoadThumbnails(
+    recording_id: string,
+    clip_id: string,
+    timeline_id: string,
+    start_offset_us: number[],
+    major_axis: number,
+    time_precision: boolean,
+  ): any;
+  // TODO: unused ?
+  ManuallyDeleteRecordingForApps(game_ids: string[]): any;
+  RegisterManualRecordingCallback(e: string, t: any): () => void;
+  ReloadAppsWithBackgroundVideoIfNecessary(e: any): void;
+  ReportClipRange(steamid: CSteamID, rangeMethod: any, seconds: any, startRange: any, endRange: any): any;
+  ReportClipShare(steamid: CSteamID, shareMethod: any, seconds: any, bytes: number, result: EResult): any;
+  SaveClip(
+    game_id: string,
+    src_clip_id: string,
+    name: string,
+    start: { timeline_id: string; offset_ms: string },
+    end: { timeline_id: string; offset_ms: string },
+    temporary: boolean,
+    force_thumbnail: boolean,
+  ): Promise<{ clipSummary?: ClipSummary_t; result: EResult }>;
+  StartRecording(gameid: string): Promise<CBaseProtoBufMsg>;
+  StopRecording(gameid: string): Promise<void>;
+  SwitchRecordedGame(gameid: string): Promise<CBaseProtoBufMsg>;
+  TakeScreenshot(
+    game_id: string,
+    timeline_id: string,
+    timeline_offset_ms: string,
+  ): Promise<{ handle?: number; result: EResult }>;
+  UpdateClipExportPath(clip_id: string, path: string): void;
+  UpdateUserTimelineMarkers(game_id: string, clip_id: string, entry: CTimelineEntry): Promise<EResult>;
+
+  /**
+   * Uploads a clip to the Steam community.
+   */
+  UploadClip(
+    clip_id: string,
+    title?: string,
+    desc?: string,
+    visibility?: EUCMFilePrivacyState,
+  ): Promise<{ eResult: EResult; strURL: string | undefined }>;
+}

package/src/globals/stores/index.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';