@decky/ui 4.15.1 → 4.16.0

package/dist/globals/stores/friendstore/friendsuifriendstore.d.ts

@@ -0,0 +1,125 @@
+import type { CCallbackList, CSteamID, Unsubscribable } from '../../shared';
+import type { EResult } from '../../steam-client/shared';
+import type { CClanStore } from './clanstore';
+import type { CFriendGroupStore } from './friendgroupstore';
+import type { CFriendInGameNotificationStore } from './friendingamenotificationstore';
+import type { CFriendsListFavoritesStore } from './friendslistfavoritesstore';
+import type { CPlayer, EFriendRelationship, EPersonaState, PerFriendNotificationSettings } from './shared';
+interface FriendStorePrefs {
+    ePersonaState: EPersonaState;
+    strNonFriendsAllowedToMsg: string;
+}
+interface SendFriendInviteResult {
+    eResult: EResult;
+    eFriendRelationship: EFriendRelationship;
+}
+interface TokenBucketChangeStatus {
+    m_numStartingTokens: number;
+    m_numTokensPerMillisecond: number;
+    m_numIntervalsPerMillisecond: number;
+    m_TimeLastChecked: number;
+    m_flTokens: number;
+    AddTokens(): void;
+    BRemoveToken(): void;
+    Reset(): void;
+}
+declare class CMsgClientFriendsList {
+}
+declare class PerFriendPreferences {
+}
+export interface CFriendsUIFriendStore {
+    m_ClanStore: CClanStore;
+    m_FavoritesStore: CFriendsListFavoritesStore;
+    m_FriendGroupStore: CFriendGroupStore;
+    m_FriendInGameNotificationStore: CFriendInGameNotificationStore;
+    m_FriendStorePrefs: FriendStorePrefs;
+    m_InitialAppInfoPromises: Promise<void>[];
+    m_TokenBucketChangeStatus: TokenBucketChangeStatus;
+    m_TokenFailureAssertCount: number;
+    m_bAwayCallbackFired: boolean;
+    m_bInitialAppInfoLoaded: boolean;
+    m_bInitialPersonaStatesLoaded: boolean;
+    m_bIsClientIdle: boolean;
+    m_bMadeGetFriendsListRequest: boolean;
+    m_bNextActivityCallbackRegistered: boolean;
+    m_bParentalLocked: boolean;
+    m_bPerFriendPreferencesLoaded: boolean;
+    m_bReadyToRender: boolean;
+    m_bReceivedFriendsList: boolean;
+    m_bReconnectedSinceLastIdleUpdate: boolean;
+    m_bSnoozeCallbackFired: boolean;
+    m_bUserSetPersonaState: boolean;
+    m_cFriendPersonaStatesInitialized: number;
+    m_cLastUnreadPriorityMessageCountPosted: number;
+    m_eUserPersonaState: EPersonaState;
+    m_eUserPersonaStateParental: EPersonaState;
+    m_iIntervalDelayLoadFriendsList: number;
+    m_iIntervalSubscribeToPersonaStateUpdates: number;
+    m_mapApprovedNonFriendMessages: Map<number, number>;
+    m_mapPlayerCache: Map<number, CPlayer>;
+    m_nMissingPersonaStateMaxRetries: number;
+    m_nMissingPersonaStateRetryCount: number;
+    m_rgPersonaStateChangeCallbacks: CCallbackList<[CPlayer]>;
+    m_rgPlayerGameChangedCallbacks: CCallbackList<[number, number, number]>;
+    m_self: CPlayer;
+    m_setFriendAccountIDs: Set<number>;
+    m_setFriendsNeedingPersonaStateLoad: Set<number>;
+    m_setIncomingInviteAccountIDs: Set<number>;
+    m_tsLastConnect: number;
+    m_vecLastTenChangeStatusReasons: string[];
+    AddFriend(steamid64: string, relationship: EFriendRelationship, dontInitPlayer: boolean): void;
+    AddPersonaStateChangedCallback(callback: (player: CPlayer) => void): Unsubscribable;
+    AddPlayerGameChangedCallback(callback: (steamid3: number, param1: number, appid: number) => void): Unsubscribable;
+    AddPlayerToCache(steamid3: number, unused0?: number, unused1?: boolean): CPlayer;
+    AdjustPersonaStateForIdleTime(state: EPersonaState): number;
+    BApprovedNonFriendMessages(steamid3: number): boolean;
+    BIsInvisibleMode(): boolean;
+    BIsOfflineMode(): boolean;
+    BlockPlayer(player: CPlayer, unblock?: boolean): Promise<EFriendRelationship>;
+    EnsureApprovedNonFriendMapReady(): void;
+    EnsureFriendsListLoaded(param0: boolean): void;
+    ForceReadyToRender(): void;
+    GetClanInviteCount(): number;
+    GetFriend(steamid3: number): CPlayer | null;
+    GetFriendIfCached(steamid3: number): CPlayer | undefined;
+    GetFriendInviteCount(): number;
+    GetFriendsList(): Promise<void>;
+    GetOnlineFriendCount(): number;
+    GetOutgoingFriendRequestCount(): number;
+    GetPendingInviteCount(): number;
+    GetPersonaStatePreference(): EPersonaState;
+    GetPlayer(steamid3: number): CPlayer;
+    GetPlayerIfCached(steamid3: number): CPlayer | undefined;
+    GetUserDoNotDisturb(): boolean;
+    InviteToGame(player: CPlayer, appid: number, connectString: string): void;
+    InviteToLobby(player: CPlayer, appid: number, steamIdLobby: string): void;
+    InviteToWatch(player: CPlayer): void;
+    PlayFriendOnlineSound(): void;
+    PlayJoinGameSound(): void;
+    RemoveFriend(player: CPlayer): Promise<EFriendRelationship>;
+    RemoveFriendBySteamID(steamid: string | CSteamID): Promise<EFriendRelationship>;
+    SendFriendInvite(player: CPlayer): Promise<SendFriendInviteResult>;
+    SendFriendInviteBySteamID(steamid: string | CSteamID): Promise<SendFriendInviteResult>;
+    SendPersonaStateToServer(needPersonaResponse: boolean, changeStatusReason: string): boolean;
+    SetApprovedNonFriendMessages(param0: number): void;
+    SetFriendsList(msg: CMsgClientFriendsList): Promise<void>;
+    SetPersonasOffline(value: boolean): void;
+    SetPlayerNickname(prefs: PerFriendPreferences, nicknane: string): Promise<EResult>;
+    SetPlayerNotificationSettings(prefs: PerFriendPreferences, notificationSettings: PerFriendNotificationSettings): Promise<EResult>;
+    SetPlayerPerFriendPreferences(prefs: PerFriendPreferences, nickname: string, notificationSettings: PerFriendNotificationSettings): Promise<EResult>;
+    SetReconnectedSinceLastIdleUpdate(): void;
+    SetUserDoNotDisturb(value: boolean): void;
+    SetUserPersonaState(state: EPersonaState, isUserSet: boolean): void;
+    UpdateUnreadMessagesGlobal(): void;
+    UpdateUserPersonaStateInternal(state: EPersonaState, isUserSet: boolean, isClientIdle: boolean, param3: boolean, changeStatusReason: string): void;
+    get all_friends(): CPlayer[];
+    get all_friends_accountids(): Set<number>;
+    get friends_list_ready(): boolean;
+    get not_ready_to_render_reason(): string;
+    get online_friends(): CPlayer[];
+    get self(): CPlayer;
+    get ClanStore(): CClanStore;
+    get FavoritesStore(): CFriendsListFavoritesStore;
+    get FriendGroupStore(): CFriendGroupStore;
+}
+export {};

package/dist/globals/stores/friendstore/friendsuifriendstore.js

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

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

@@ -0,0 +1,25 @@
+import type { CSteamID } from '../../shared';
+import type { EResult } from '../../steam-client/shared';
+import type { CFriendsUIFriendStore } from './friendsuifriendstore';
+import type { CPlayer } from './shared';
+export declare class CFriendStore {
+    m_FriendsUIFriendStore: CFriendsUIFriendStore;
+    m_mapOwnedGamesCacheErrors: Map<number, EResult>;
+    m_mapPlayerCache: Map<number, CPlayer>;
+    BShouldCachePlayer(persona: CPlayer): boolean;
+    FetchOwnedGames(steamid3: number): Promise<{
+        setApps: Set<number>;
+    }>;
+    GetCountFriendsInGame(appid: number): number;
+    GetCountFriendsPlayingGames(): number;
+    GetFriendState(friend: number | CSteamID): CPlayer;
+    GetFriendsInGame(appid: number): CPlayer[];
+    GetMaxCountFriendsInGame(): number;
+    GetOwnedGames(steamid3: number): Set<number>;
+    IsLibraryAccessDenied(steamid3: number): boolean;
+    LoadPersonaState(friend: number | CSteamID): Promise<CPlayer>;
+    RefreshOwnedGames(steamid3: number): void;
+    get allFriends(): CPlayer[];
+    get currentUserSteamID(): CSteamID;
+    get favoriteFriends(): CPlayer[];
+}

package/dist/globals/stores/friendstore/index.js

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

package/dist/globals/stores/friendstore/shared.d.ts

@@ -0,0 +1,207 @@
+import type { BrowserContext, CSteamID } from '../../shared';
+import type { CChat } from './friendchat';
+export declare enum EClientPersonaStateFlag {
+    k_EClientPersonaStateFlagStatus = 1,
+    k_EClientPersonaStateFlagPlayerName = 2,
+    k_EClientPersonaStateFlagQueryPort = 4,
+    k_EClientPersonaStateFlagSourceID = 8,
+    k_EClientPersonaStateFlagPresence = 16,
+    k_EClientPersonaStateFlagLastSeen = 32,
+    k_EClientPersonaStateFlagUserClanRank = 64,
+    k_EClientPersonaStateGameExtraInfo = 128,
+    k_EClientPersonaStateGameDataBlob = 256,
+    k_EClientPersonaStateFlagClanData = 512,
+    k_EClientPersonaStateFlagFacebook = 1024,
+    k_EClientPersonaStateFlagRichPresence = 2048,
+    k_EClientPersonaStateFlagBroadcast = 4096,
+    k_EClientPersonaStateFlagWatching = 8192
+}
+export declare enum EFriendRelationship {
+    None = 0,
+    Blocked = 1,
+    RequestRecipient = 2,
+    Friend = 3,
+    RequestInitiator = 4,
+    Ignored = 5,
+    IgnoredFriend = 6,
+    Suggested_DEPRECATED = 7,
+    Max = 8
+}
+export declare enum EPersonaState {
+    Offline = 0,
+    Online = 1,
+    Busy = 2,
+    Away = 3,
+    Snooze = 4,
+    LookingToTrade = 5,
+    LookingToPlay = 6,
+    Invisible = 7,
+    Max = 8
+}
+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;
+    BHasAvatarSet(): boolean;
+    BIsAppInfoReady(): boolean;
+    GetAccountID(): number;
+    GetCommunityProfileURL(): string;
+    GetCurrentGameName(): string;
+    GetCurrentGameIconURL(): string;
+    HasCurrentGameRichPresence(): boolean;
+    HasRichPresenceForViewGameInfo(): boolean;
+    GetCurrentGameRichPresence(): string;
+    GetCurrentGameStatus(): string;
+    GetOfflineStatusUpdateRate(): number;
+    GetOfflineStatusTime(): string;
+    GetLocalizedOnlineStatus(): string;
+    HasStateFlag(flag: EClientPersonaStateFlag): boolean;
+    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;
+    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;
+    EnsureCommunityDataLoaded(): void;
+    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;
+    GetBroadcastDescription(): string | null;
+    GetCommunityProfileURL(): string;
+    GetEquippedProfileItems(): CPlayer_GetProfileItemsEquipped_Response;
+    LoadAndSetGoldenProfileFrame(): Promise<void>;
+    LoadEquippedProfileItems(e: boolean): Promise<void>;
+    LoadIfNecessary(): void;
+    MatchSearchString(s: string): {
+        bFullMatch: boolean;
+        iOffset: number;
+        match: number;
+    };
+    OpenChatDialog(browser: BrowserContext): CChat;
+    SetLastSeenPlaying(appid: number): void;
+    SetPersonaStateUpdated(): void;
+    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;
+    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;
+}
+export {};

package/dist/globals/stores/friendstore/shared.js

@@ -0,0 +1,41 @@
+export var EClientPersonaStateFlag;
+(function (EClientPersonaStateFlag) {
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagStatus"] = 1] = "k_EClientPersonaStateFlagStatus";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagPlayerName"] = 2] = "k_EClientPersonaStateFlagPlayerName";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagQueryPort"] = 4] = "k_EClientPersonaStateFlagQueryPort";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagSourceID"] = 8] = "k_EClientPersonaStateFlagSourceID";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagPresence"] = 16] = "k_EClientPersonaStateFlagPresence";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagLastSeen"] = 32] = "k_EClientPersonaStateFlagLastSeen";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagUserClanRank"] = 64] = "k_EClientPersonaStateFlagUserClanRank";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateGameExtraInfo"] = 128] = "k_EClientPersonaStateGameExtraInfo";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateGameDataBlob"] = 256] = "k_EClientPersonaStateGameDataBlob";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagClanData"] = 512] = "k_EClientPersonaStateFlagClanData";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagFacebook"] = 1024] = "k_EClientPersonaStateFlagFacebook";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagRichPresence"] = 2048] = "k_EClientPersonaStateFlagRichPresence";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagBroadcast"] = 4096] = "k_EClientPersonaStateFlagBroadcast";
+    EClientPersonaStateFlag[EClientPersonaStateFlag["k_EClientPersonaStateFlagWatching"] = 8192] = "k_EClientPersonaStateFlagWatching";
+})(EClientPersonaStateFlag || (EClientPersonaStateFlag = {}));
+export var EFriendRelationship;
+(function (EFriendRelationship) {
+    EFriendRelationship[EFriendRelationship["None"] = 0] = "None";
+    EFriendRelationship[EFriendRelationship["Blocked"] = 1] = "Blocked";
+    EFriendRelationship[EFriendRelationship["RequestRecipient"] = 2] = "RequestRecipient";
+    EFriendRelationship[EFriendRelationship["Friend"] = 3] = "Friend";
+    EFriendRelationship[EFriendRelationship["RequestInitiator"] = 4] = "RequestInitiator";
+    EFriendRelationship[EFriendRelationship["Ignored"] = 5] = "Ignored";
+    EFriendRelationship[EFriendRelationship["IgnoredFriend"] = 6] = "IgnoredFriend";
+    EFriendRelationship[EFriendRelationship["Suggested_DEPRECATED"] = 7] = "Suggested_DEPRECATED";
+    EFriendRelationship[EFriendRelationship["Max"] = 8] = "Max";
+})(EFriendRelationship || (EFriendRelationship = {}));
+export var EPersonaState;
+(function (EPersonaState) {
+    EPersonaState[EPersonaState["Offline"] = 0] = "Offline";
+    EPersonaState[EPersonaState["Online"] = 1] = "Online";
+    EPersonaState[EPersonaState["Busy"] = 2] = "Busy";
+    EPersonaState[EPersonaState["Away"] = 3] = "Away";
+    EPersonaState[EPersonaState["Snooze"] = 4] = "Snooze";
+    EPersonaState[EPersonaState["LookingToTrade"] = 5] = "LookingToTrade";
+    EPersonaState[EPersonaState["LookingToPlay"] = 6] = "LookingToPlay";
+    EPersonaState[EPersonaState["Invisible"] = 7] = "Invisible";
+    EPersonaState[EPersonaState["Max"] = 8] = "Max";
+})(EPersonaState || (EPersonaState = {}));

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

@@ -0,0 +1,263 @@
+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';
+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;
+}
+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;
+    progress: number;
+    resultStatus: EResult;
+}
+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;
+    BEnoughDiskSpace(): boolean;
+    BLoadingAppsWithBackgroundVideo(): boolean;
+    BLoadingClips(): boolean;
+    CheckEnoughDiskSpace(): Promise<void>;
+    CreateUserTimelineMarkers(game_id: string, clip_id: string, entry: CTimelineEntry): Promise<{
+        eResult: EResult;
+        entry_id: string;
+    }>;
+    DeleteClip(clip_id: string): Promise<EResult>;
+    ExportClip(clip_id: string, export_mp4_path: string, settings: CGameRecording_ExportClip_Settings, use_unique_filename: boolean): Promise<EResult>;
+    GetAchievementInfo(appid: number, id: string): {
+        description: string;
+        iconURL: string;
+        name: string;
+    };
+    GetAppsWithBackgroundVideo(): AppWithTimeline_t[];
+    GetAvailableDiskSpace(): Promise<number>;
+    GetBestClipTitle(clip_id: string): string;
+    GetClipExportProgress(clipID: string): ClipExportProgress_t | undefined;
+    GetClipIDs(gameid: string): string[];
+    GetClipSummaries(clipIDs: string[]): ClipSummary_t[];
+    GetClipSummariesForGame(gameid: string): ClipSummary_t[] | null;
+    GetClipSummary(clipID: string): ClipSummary_t;
+    GetCurrentExportingClip(): string | null;
+    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;
+    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>;
+    UploadClip(clip_id: string, title?: string, desc?: string, visibility?: EUCMFilePrivacyState): Promise<{
+        eResult: EResult;
+        strURL: string | undefined;
+    }>;
+}
+export {};

package/dist/globals/stores/gamerecordingstore.js

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