@decky/ui 4.15.0 → 4.16.0

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

@@ -0,0 +1,374 @@
+import type { ReactNode } from 'react';
+import type { BrowserContext, CCallbackList } from '../../shared';
+import type { EResult } from '../../steam-client/shared';
+import type { ClipSummary_t } from '../gamerecordingstore';
+import type { CPlayer } from './shared';
+export declare enum EMessageReactionType {
+    k_EMessageReactionType_Invalid = 0,
+    k_EMessageReactionType_Emoticon = 1,
+    k_EMessageReactionType_Sticker = 2
+}
+export declare enum EMsgAnimationState {
+    None = 0,
+    Animating = 1
+}
+export declare enum EChatMsgDeleteState {
+    None = 0,
+    Deleting = 1,
+    Deleted = 2
+}
+export declare enum EChatMsgSendError {
+    None = 0,
+    Generic = 1,
+    NotFriends = 2,
+    NoChatPermissionInGroup = 3,
+    RateLimitExceeded = 4
+}
+export declare enum EChatRoomServerMessage {
+    k_EChatRoomServerMsg_Invalid = 0,
+    k_EChatRoomServerMsg_RenameChatRoom = 1,
+    k_EChatRoomServerMsg_Joined = 2,
+    k_EChatRoomServerMsg_Parted = 3,
+    k_EChatRoomServerMsg_Kicked = 4,
+    k_EChatRoomServerMsg_Invited = 5,
+    k_EChatRoomServerMsg_InviteDismissed = 6,
+    k_EChatRoomServerMsg_ChatRoomTaglineChanged = 7,
+    k_EChatRoomServerMsg_ChatRoomAvatarChanged = 8,
+    k_EChatRoomServerMsg_AppCustom = 9
+}
+export declare enum EChatWindowState {
+    Unopened = 0,
+    Hidden = 1,
+    Visible = 2,
+    FocusedIdle = 3,
+    FocusedActive = 4
+}
+export declare enum EFileUploadState {
+    None = 0,
+    FileReady = 1,
+    InProgress = 2,
+    Error = 3,
+    Error_ImageTooLarge = 4,
+    Error_FileTypeNotSupported = 5,
+    Completed = 6
+}
+interface Reaction_t {
+    eReactionType: EMessageReactionType;
+    strReaction: string;
+    cReactors: number;
+    bUserReacted: boolean;
+}
+export declare class CChatMessageBlock {
+    m_bMessageBlockIsOnlyEmotes: boolean;
+    m_nextBlock: this;
+    m_rgMessages: ChatMsg_t[];
+    m_rtMidnightBeforeBlock: number;
+    AppendMessage(msg: ChatMsg_t): void;
+    BCanAccumulateMessage(msg: ChatMsg_t): boolean;
+    BIsInvite(): boolean;
+    BIsLocalMsg(): boolean;
+    BIsServerMsg(): boolean;
+    CreateVirtualSplitOnTimestamp(ts: number): CChatMessageBlock[];
+    GetRTimeFirstMessage(): number;
+    GetRTimeLastMessage(): number;
+    GetRTimeMidnightBeforeBlock(): number;
+    GetRTimeMidnightBeforeNextBlock(): number;
+    RemoveLocalMessage(msg: ChatMsg_t): boolean;
+    SetNextBlock(block: CChatMessageBlock): void;
+    UniqueKey(): number;
+}
+export declare class CChatMessageBlockList {
+    m_iIndexLastTimePassesGap: number | undefined;
+    m_rgMessageBlocks: CChatMessageBlock[];
+    AppendMessage(msg: ChatMsg_t): void;
+    AppendNewMessage(msg: ChatMsg_t): void;
+    BuildMessageBlocks(msgs: ChatMsg_t[]): void;
+    Clear(): void;
+    RemoveLocalMessage(msg: ChatMsg_t): boolean;
+    RemoveOldestMessages(param0: number): CChatMessageBlock[] | null;
+}
+type ChatRoomEffect_t = 'balloons' | 'confetti' | 'firework' | 'goldfetti' | 'lny2020_confetti' | 'lny2020_firework' | 'lny2020_lanterns' | 'snow' | 'snowball';
+interface ChatRoomEffectSettings {
+    buttonToken: string;
+    locToken: string;
+    render(...args: any[]): ReactNode;
+    renderButton(): ReactNode;
+    renderEffectIcon(): ReactNode;
+    timeout: number;
+}
+declare class ChatRoomEffectInstance {
+    name: string;
+    timestamp: number;
+    expires: number;
+    settings: ChatRoomEffectSettings;
+    Queue(): string;
+    bIsExpired(): boolean;
+    bIsActive(): boolean;
+    iTimeToExpiry(): number;
+    render(): ReactNode | null;
+}
+export declare class CChatRoomEffectManager {
+    m_effectSettings: {
+        [effect in ChatRoomEffect_t]: ChatRoomEffectSettings;
+    };
+    m_mapRoomEffectQueue: {
+        [effect in ChatRoomEffect_t]: ChatRoomEffectInstance[];
+    };
+    m_rgRunningEffects: ChatRoomEffectInstance[];
+    ActivateRoomEffect(instance: ChatRoomEffectInstance): void;
+    AddRoomEffect(name: ChatRoomEffect_t): void;
+    BIsQueueFull(name: ChatRoomEffect_t): boolean;
+    QueueRoomEffect(name: ChatRoomEffect_t): void;
+    UpdateRunningRoomEffects(): void;
+}
+interface SendQueueEntry_t {
+    eError?: EChatMsgSendError;
+    id?: string;
+    message: string;
+    timestamp: number;
+}
+export declare class CPerChatSendQueue {
+    m_id: string;
+    m_queue: SendQueueEntry_t[];
+    Add(msg: string): string;
+    GetItemID(item: SendQueueEntry_t): string;
+    GetItemIndex(item: SendQueueEntry_t): number;
+    RemoveItem(index: number): void;
+    SetItemFailed(item: SendQueueEntry_t, error: number): void;
+    UpdateStoredQueue(): void;
+    get queued_messages(): SendQueueEntry_t[];
+}
+interface FileUploadInfo_t {
+    bSpoiler: boolean;
+}
+interface FileUploadProps_t {
+    dataURL: string | undefined;
+    displayFileName: string | undefined;
+    eUploadState: EFileUploadState;
+    exportFn: ((...args: any[]) => any) | undefined;
+    file: File | null | undefined;
+    fileInfo: any;
+    hmac: string | undefined;
+    imageHeight: number;
+    imageWidth: number;
+    sha1: string | undefined;
+    strErrorDescription: string | undefined;
+    timestamp: number;
+    uploadFileName: string | undefined;
+    uploadInfo: FileUploadInfo_t;
+    uploadProgress: number;
+}
+interface idk {
+    displayFilename?: string;
+    info: FileUploadInfo_t;
+    onComplete?: (result: EResult, size: number) => void;
+    processor?: any;
+    unAssociatedAppID?: number;
+}
+interface CFileUploadManager {
+    m_Callbacks: CChat;
+    m_fileUploadProps: FileUploadProps_t;
+    m_onComplete: ((result: EResult, size: number) => void) | undefined;
+    BeginFileUpload(uploadInfo: FileUploadInfo_t): Promise<Response | null>;
+    ClearFileUploadError(): void;
+    CommitFileUpload(bSuccess: boolean, ugcid: string): Promise<Response | null>;
+    DoFileUpload(options: any): Promise<Response | null>;
+    LogFileUploadMessage(msg: string): void;
+    Reset(): void;
+    RetryFileUpload(): Promise<Response | null>;
+    SetFileToUpload(fileOrExportFn: File | ((...args: any[]) => any) | null): void;
+    SetImageFileToUpload(file: File | null, t: idk): Promise<void>;
+    SetOtherFileToUpload(file: File | null, t: idk): Promise<void>;
+    SetUploadFileError(state: EFileUploadState, description: string): void;
+    StartFileExportToUpload(file: File | null, t: idk): Promise<void>;
+    get file(): File | null;
+    get file_upload_data_url(): string | null;
+    get file_upload_props(): FileUploadProps_t;
+}
+declare class CChatTabSet {
+    m_activeTab: CChatView;
+    m_browserContext: BrowserContext;
+    m_id: number;
+    m_vecTabs: CChatView[];
+    ActivateNextTab(): void;
+    ActivatePreviousTab(): void;
+    ActivateTab(tab: CChatView): void;
+    AddTab(tab: CChatView): void;
+    BHasTab(tab: CChatView): boolean;
+    CloseAllTabs(): void;
+    DeactivateTab(tab: CChatView): void;
+    Focus(): void;
+    FocusActiveTab(): void;
+    GetBrowserContext(): BrowserContext;
+    GetTabByUniqueID(id: string): CChatView | null;
+    GetTabForChat(chat: CChat): CChatView | null;
+    GetTabSetIdentifier(): string;
+    GetTitle(): string;
+    MoveTabAfter(tabA: CChatView, tabB: CChatView): void;
+    MoveTabToIndex(tab: CChatView, index: number): void;
+    OnPopupClosed(): void;
+    OnWindowFocus(): void;
+    RemoveTab(tab: CChatView): boolean;
+    Serialize(): {
+        active_tab: string;
+        tabs: string[];
+    };
+    get activeTab(): CChatView;
+    get is_popup_active(): boolean;
+    get is_popup_focused(): boolean;
+    get is_popup_visible(): boolean;
+    get tabCount(): number;
+    get tabs(): this['m_vecTabs'];
+}
+export interface CChatView {
+    m_bScrolledToBottom: boolean;
+    m_chat: CChat;
+    m_clientHeight: number;
+    m_clipToUpload: ClipSummary_t | undefined;
+    m_fileUploadManager: CFileUploadManager;
+    m_msLastActive: number;
+    m_rgOnChatFrameChangedCallbacks: (() => void)[];
+    m_rgOnChatRequestScrollBottomCallbacks: (() => void)[];
+    m_scrollHeight: number;
+    m_scrollTop: number;
+    m_strTextEntry: string;
+    m_tabset: CChatTabSet;
+    m_textEntryChangeCallbacks: CCallbackList;
+    m_textEntryFocusCallbacks: CCallbackList;
+    AddOnChatFrameChangedCallback(callback: () => void): void;
+    AddOnChatRequestScrollBottomCallback(callback: () => void): void;
+    AddPendingText(text: string): void;
+    BIsInBrowserContext(browser: BrowserContext): boolean;
+    BVoiceActive(): boolean;
+    CheckActivationAndNotifyChat(): void;
+    ConvertMessageToBBCode(msg: string): string;
+    FocusTextInput(): void;
+    GetChatView(): this;
+    GetTabName(): string;
+    GetUniqueID(): string;
+    GetUnreadMessageCount(): number;
+    GetVisibilityState(): EChatWindowState;
+    InternalOnTabActivate(): void;
+    IsChatRoom(): boolean;
+    IsFriendChat(): boolean;
+    IsTabForChat(chat: CChat): boolean;
+    IsVoiceActive(): boolean;
+    OnActivate(): void;
+    OnChatFrameChanged(): void;
+    OnDeactivate(): void;
+    OnFocus(): void;
+    OnScrollBottomRequest(): void;
+    OnTabClosed(): void;
+    OnTabDeactivate(): void;
+    OnTabFocus(): void;
+    OnViewClosed(): void;
+    RegisterForTextEntryFocus(callback: any): void;
+    RegisterForTextUpdated(callback: any): void;
+    RemoveOnChatFrameChangedCallback(callback: () => void): void;
+    RemoveOnChatRequestScrollBottomCallback(callback: () => void): void;
+    SendChatMessage(msg: string): Promise<void>;
+    SetClipToUpload(clip: ClipSummary_t): void;
+    SetFileToUpload(file: File | null, t?: idk): void;
+    StartFileExportToUpload(file: File | null, t?: idk): any;
+    UploadFile(spoiler: boolean): Promise<void>;
+}
+export declare class ChatMsg_t {
+    eAnimationState: EMsgAnimationState;
+    eDeleteState: EChatMsgDeleteState;
+    eServerMsgType: EChatRoomServerMessage | undefined;
+    m_bNoUserContent: boolean | undefined;
+    m_mentions: any | undefined;
+    m_rgReactions: Reaction_t[];
+    m_strSlashCommand: string | undefined;
+    rtTimestamp: number;
+    strMessageInternal: string;
+    strServerMsgAppCustomLocalized: string | undefined;
+    strServerMsgParam: string | undefined;
+    unAccountID: number;
+    unOrdinal: number;
+    unServerMsgParamAccountID: number | undefined;
+    BHasServerAcknowledged(): boolean;
+    BIsInvite(): boolean;
+    BIsLocalEcho(): boolean;
+    BIsNewerThan(ts: number): boolean;
+    BIsOlderThan(ts: number): boolean;
+    BIsServerMessage(): boolean;
+    GetSlashCommand(): string | null;
+    HasUserContent(): boolean;
+    UniqueKey(): number | string;
+    UpdateReaction(eReactionType: EMessageReactionType, strReaction: string, cReactors: number, bUserReacted: boolean): Reaction_t;
+    get Mentions(): any;
+}
+export declare class CChat {
+    m_ChatMessageBlockList: CChatMessageBlockList;
+    m_MessageSendQueue: CPerChatSendQueue;
+    m_accountIDLastMessage: number | undefined;
+    m_bChatLogsLoaded: boolean;
+    m_bFriendIsTyping: boolean;
+    m_bHasUnreadPriorityChatMessages: boolean;
+    m_bMoreAvailable: boolean;
+    m_bNeedsNonFriendWarning: boolean;
+    m_bPrepended: boolean;
+    m_bReceivedChatLogs: boolean;
+    m_cUnreadChatMessages: number;
+    m_chatRoomEffects: CChatRoomEffectManager;
+    m_iClearFriendIsTypingInterval: number | undefined;
+    m_msTimeActivated: number;
+    m_nLoadingHistoryInProgressCount: number;
+    m_oldestMessageOrdinal: number;
+    m_oldestMessageTime: number;
+    m_rgChatMessages: ChatMsg_t[];
+    m_rgChatViews: CChatView[];
+    m_rtFirstUnread: number;
+    m_rtFirstUnreadChatMsg: number;
+    m_rtLastAckedChatMsg: number;
+    m_rtLastMessageReceived: number;
+    m_rtLastServerAckedChatMsg: number;
+    m_rtLastServerMessageReceived: number;
+    m_setInflightClientMessageID: Set<string>;
+    m_strLastMessage: string | undefined;
+    m_tsLastSentTypingNotification: number | undefined;
+    m_unAccountIDFriend: number;
+    AckChatMsgOnServer(e: any): any;
+    BIsVoiceAllowed(): boolean;
+    BVoiceActive(): boolean;
+    CheckShouldNotify(e: any, t: any, r: any): any;
+    ClearFriendIsTypingState(): any;
+    GetBBCodeParser(): any;
+    GetLastMessage(): string;
+    GetMember(steamid3: number): CPlayer;
+    GetMessageReactionReactors(e: any, t: any, r: any): any;
+    GetMessagesFromResponse(e: any): any;
+    GetMessagesFromTimeRange(e: any, t: any, r: any, i: any, a: any): any;
+    GetShowNonFriendWarning(): any;
+    GetVoiceNotAllowedReason(): string | null;
+    OnFriendTypingNotification(): any;
+    OnNewChatMsgAdded(e: any, t: any, r: any, n: any): any;
+    OnReceivedNewMessage(e: any, t: any, r: any, n: any): any;
+    OnTyping(): any;
+    PopulateCommitFileUploadFormData(e: FormData, t: FileUploadInfo_t, r: idk): any;
+    SendChatMessage(content: string): Promise<void>;
+    SendChatMessageInternal(content: string): Promise<EChatMsgSendError>;
+    SetShowNonFriendWarning(value: boolean): void;
+    ToggleVoiceChat(): true;
+    UpdateMessageReaction(msg: ChatMsg_t, eType: EMessageReactionType, strReaction: string, bUserAdded: boolean): Promise<EResult>;
+    ViewerNeedsApproval(requestid: number): void;
+    get BIsPrepend(): boolean;
+    get accountid_last_message(): number | undefined;
+    get accountid_partner(): number;
+    get chat_message_blocks(): CChatMessageBlockList;
+    get chat_messages(): ChatMsg_t[];
+    get chat_partner(): CPlayer;
+    get first_unread_msg_time(): number;
+    get has_unread_priority_messages(): boolean;
+    get is_blocked_friend(): boolean;
+    get is_friend_typing(): boolean;
+    get last_voice_participation_time(): number;
+    get name(): string;
+    get self(): CPlayer;
+    get time_last_ack(): number;
+    get time_last_message(): number;
+    get unique_id(): string;
+    get unread_message_count(): number;
+}
+export {};

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

@@ -0,0 +1,56 @@
+export var EMessageReactionType;
+(function (EMessageReactionType) {
+    EMessageReactionType[EMessageReactionType["k_EMessageReactionType_Invalid"] = 0] = "k_EMessageReactionType_Invalid";
+    EMessageReactionType[EMessageReactionType["k_EMessageReactionType_Emoticon"] = 1] = "k_EMessageReactionType_Emoticon";
+    EMessageReactionType[EMessageReactionType["k_EMessageReactionType_Sticker"] = 2] = "k_EMessageReactionType_Sticker";
+})(EMessageReactionType || (EMessageReactionType = {}));
+export var EMsgAnimationState;
+(function (EMsgAnimationState) {
+    EMsgAnimationState[EMsgAnimationState["None"] = 0] = "None";
+    EMsgAnimationState[EMsgAnimationState["Animating"] = 1] = "Animating";
+})(EMsgAnimationState || (EMsgAnimationState = {}));
+export var EChatMsgDeleteState;
+(function (EChatMsgDeleteState) {
+    EChatMsgDeleteState[EChatMsgDeleteState["None"] = 0] = "None";
+    EChatMsgDeleteState[EChatMsgDeleteState["Deleting"] = 1] = "Deleting";
+    EChatMsgDeleteState[EChatMsgDeleteState["Deleted"] = 2] = "Deleted";
+})(EChatMsgDeleteState || (EChatMsgDeleteState = {}));
+export var EChatMsgSendError;
+(function (EChatMsgSendError) {
+    EChatMsgSendError[EChatMsgSendError["None"] = 0] = "None";
+    EChatMsgSendError[EChatMsgSendError["Generic"] = 1] = "Generic";
+    EChatMsgSendError[EChatMsgSendError["NotFriends"] = 2] = "NotFriends";
+    EChatMsgSendError[EChatMsgSendError["NoChatPermissionInGroup"] = 3] = "NoChatPermissionInGroup";
+    EChatMsgSendError[EChatMsgSendError["RateLimitExceeded"] = 4] = "RateLimitExceeded";
+})(EChatMsgSendError || (EChatMsgSendError = {}));
+export var EChatRoomServerMessage;
+(function (EChatRoomServerMessage) {
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_Invalid"] = 0] = "k_EChatRoomServerMsg_Invalid";
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_RenameChatRoom"] = 1] = "k_EChatRoomServerMsg_RenameChatRoom";
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_Joined"] = 2] = "k_EChatRoomServerMsg_Joined";
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_Parted"] = 3] = "k_EChatRoomServerMsg_Parted";
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_Kicked"] = 4] = "k_EChatRoomServerMsg_Kicked";
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_Invited"] = 5] = "k_EChatRoomServerMsg_Invited";
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_InviteDismissed"] = 6] = "k_EChatRoomServerMsg_InviteDismissed";
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_ChatRoomTaglineChanged"] = 7] = "k_EChatRoomServerMsg_ChatRoomTaglineChanged";
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_ChatRoomAvatarChanged"] = 8] = "k_EChatRoomServerMsg_ChatRoomAvatarChanged";
+    EChatRoomServerMessage[EChatRoomServerMessage["k_EChatRoomServerMsg_AppCustom"] = 9] = "k_EChatRoomServerMsg_AppCustom";
+})(EChatRoomServerMessage || (EChatRoomServerMessage = {}));
+export var EChatWindowState;
+(function (EChatWindowState) {
+    EChatWindowState[EChatWindowState["Unopened"] = 0] = "Unopened";
+    EChatWindowState[EChatWindowState["Hidden"] = 1] = "Hidden";
+    EChatWindowState[EChatWindowState["Visible"] = 2] = "Visible";
+    EChatWindowState[EChatWindowState["FocusedIdle"] = 3] = "FocusedIdle";
+    EChatWindowState[EChatWindowState["FocusedActive"] = 4] = "FocusedActive";
+})(EChatWindowState || (EChatWindowState = {}));
+export var EFileUploadState;
+(function (EFileUploadState) {
+    EFileUploadState[EFileUploadState["None"] = 0] = "None";
+    EFileUploadState[EFileUploadState["FileReady"] = 1] = "FileReady";
+    EFileUploadState[EFileUploadState["InProgress"] = 2] = "InProgress";
+    EFileUploadState[EFileUploadState["Error"] = 3] = "Error";
+    EFileUploadState[EFileUploadState["Error_ImageTooLarge"] = 4] = "Error_ImageTooLarge";
+    EFileUploadState[EFileUploadState["Error_FileTypeNotSupported"] = 5] = "Error_FileTypeNotSupported";
+    EFileUploadState[EFileUploadState["Completed"] = 6] = "Completed";
+})(EFileUploadState || (EFileUploadState = {}));

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

@@ -0,0 +1,98 @@
+import type { CPlayer } from './shared';
+import type { CFriendStore } from '.';
+export declare enum FriendGroupDisplayType {
+    eOnlineOnly = 0,
+    eOnlineOnlyNotInGame = 1,
+    eOfflineOnly = 2,
+    eIncomingInvites = 3,
+    eAll = 4
+}
+type FriendGroup_t = 'offline' | 'outgoing';
+interface CFriendGroupDisplayPrefs {
+    m_mapCollapsePrefs: Map<FriendGroup_t, boolean>;
+    GetUserGroupCollapsed(group: FriendGroup_t): boolean;
+    SetUserGroupCollapsed(group: FriendGroup_t, value: boolean): void;
+    ToggleUserGroupCollapsed(group: FriendGroup_t): void;
+    WritePrefs(): void;
+}
+interface CFriendGroup {
+    m_OnHeaderClick: any;
+    m_bAcceptsGroupRemovals: boolean;
+    m_bCollapsed: boolean;
+    m_bModifiable: boolean;
+    m_eDisplayType: FriendGroupDisplayType;
+    m_iGroupID: number;
+    m_rgAccountIDMembers: number[];
+    m_setMembers: Set<number>;
+    m_strName: string;
+    AddMember(steamid3: number): void;
+    Clear(): void;
+    GetCurrentMemberSet(): Set<number>;
+    GetMembersMatchingSearch(s: string): CPlayer[];
+    HasMember(steamid3: number): boolean;
+    RemoveMember(steamid3: number): void;
+    get GetRawMemberList(): CPlayer[];
+    get accepts_group_removals(): boolean;
+    get collapsed(): boolean;
+    get display_type(): FriendGroupDisplayType;
+    get icon_url(): string;
+    get id(): number;
+    get member_accountid_list(): number[];
+    get member_count(): number;
+    get member_counts(): {
+        ingame: number;
+        online: number;
+    };
+    get member_list(): CPlayer[];
+    get member_list_unsorted(): CPlayer[];
+    get modifiable(): boolean;
+    get name(): string;
+    get onheaderclick(): any;
+    get should_filter_categorized_friends(): boolean;
+    get unfiltered_count(): number;
+    get unique_id(): string;
+}
+interface CAllIncomingInvitesFriendsGroup extends CFriendGroup {
+    m_mapSteamIDToMutualFriends: Map<any, any>;
+    m_unMutualFriendsCacheHash: number;
+    GetMutualFriendsCacheHash(): number;
+    SetMutualFriends(e: Map<any, any>): void;
+    SetMutualFriendsCacheHash(e: number): void;
+}
+interface CFriendGameGroup extends CFriendGroup {
+    PlayerGroupSortComparator(e: CPlayer, t: CPlayer, r: Map<string, number>, n: any): any;
+}
+export declare class CFriendGroupStore {
+    m_FriendGroupDisplayPrefs: CFriendGroupDisplayPrefs;
+    m_FriendStore: CFriendStore;
+    m_groupAllFriends: CFriendGroup;
+    m_groupIncomingInvites: CAllIncomingInvitesFriendsGroup;
+    m_groupIngameFriends: CFriendGroup;
+    m_groupOfflineFriends: CFriendGroup;
+    m_groupOutgoingInvites: CFriendGroup;
+    m_mapGameGroups: Map<number, CFriendGameGroup>;
+    m_mapGroups: Map<number, CFriendGroup>;
+    m_nonSteamGameGroup: CFriendGameGroup;
+    m_singletonGameGroup: CFriendGameGroup;
+    CreateGroup(name: string, friends: string[]): Promise<boolean>;
+    EnsureMutualFriendsForIncomingInvites(): void;
+    GetCountFriendsInGame(appid: number): number;
+    GetGameGroup(appid: number): CFriendGameGroup;
+    GetMaxCountFriendsInGame(): number;
+    ManageGroup(group: CFriendGroup, name: string, addedFriends?: string[], removedFriends?: string[]): Promise<boolean>;
+    RemoveGroup(group: CFriendGroup): void;
+    TransferFriendFromToGroup(player: CPlayer, groupA: CFriendGroup, groupB: CFriendGroup): Promise<boolean[]>;
+    get all_friends(): CFriendGroup;
+    get ingame_group(): CFriendGroup;
+    get incoming_invites_group(): CAllIncomingInvitesFriendsGroup;
+    get outgoing_invites_group(): CFriendGroup;
+    get friend_groups(): [...this['game_groups'], ...this['user_groups'], ...this['default_groups']];
+    get groupDisplayPrefs(): CFriendGroupDisplayPrefs;
+    get user_groups(): CFriendGroup[];
+    get game_groups(): CFriendGameGroup[];
+    get singleton_game_group(): this['m_singletonGameGroup'];
+    get categorized_friend_set(): Set<number>;
+    get default_groups(): CFriendGroup[];
+    get games_with_friends_playing(): number[];
+}
+export {};

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

@@ -0,0 +1,8 @@
+export var FriendGroupDisplayType;
+(function (FriendGroupDisplayType) {
+    FriendGroupDisplayType[FriendGroupDisplayType["eOnlineOnly"] = 0] = "eOnlineOnly";
+    FriendGroupDisplayType[FriendGroupDisplayType["eOnlineOnlyNotInGame"] = 1] = "eOnlineOnlyNotInGame";
+    FriendGroupDisplayType[FriendGroupDisplayType["eOfflineOnly"] = 2] = "eOfflineOnly";
+    FriendGroupDisplayType[FriendGroupDisplayType["eIncomingInvites"] = 3] = "eIncomingInvites";
+    FriendGroupDisplayType[FriendGroupDisplayType["eAll"] = 4] = "eAll";
+})(FriendGroupDisplayType || (FriendGroupDisplayType = {}));

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

@@ -0,0 +1,2 @@
+export declare class CFriendInGameNotificationStore {
+}

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

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

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

@@ -0,0 +1,22 @@
+import type { CClan, CClanStore } from './clanstore';
+import type { CChat } from './friendchat';
+import type { CPlayer } from './shared';
+import type { CFriendStore } from '.';
+type FavoriteEntry_t = {
+    friend: CPlayer;
+} | {
+    chat: CChat;
+} | {
+    clan: CClan;
+};
+export declare class CFriendsListFavoritesStore {
+    m_ChatStore: any;
+    m_ClanStore: CClanStore;
+    m_FriendStore: CFriendStore;
+    m_rgFavorites: FavoriteEntry_t[];
+    AddToFavorites(entry: FavoriteEntry_t, index?: number): Promise<boolean>;
+    BIsFavorited(entry: FavoriteEntry_t): boolean;
+    RemoveFromFavorites(entry: FavoriteEntry_t): Promise<boolean>;
+    SaveFavorites(): Promise<boolean>;
+}
+export {};

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

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