steamworks-ffi-node 0.5.0 → 0.5.2

package/README.md

@@ -3,17 +3,23 @@
 
 # Steamworks FFI - Steamworks SDK Integration
 
-A production-ready TypeScript/JavaScript wrapper for the Steamworks SDK using Koffi FFI, designed for Node.js and Electron applications with **Steamworks SDK integration**.
+A production-ready TypeScript/JavaScript wrapper for the Steamworks SDK using Koffi FFI, designed for Node.js and Electron applications with **Steamworks SDK v1.62 integration**.
 
 > ✅ **No C++ Compilation Required**: Uses Koffi FFI for seamless installation without Visual Studio Build Tools!
 
+> ⚡ **Latest Steamworks SDK**: Built with Steamworks SDK v1.62 - includes all latest Steam features and improvements!
+
 > 🎉 **NEW: 100% Achievement API Coverage** - All 20 Steam achievement functions implemented! [See Documentation](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/ACHIEVEMENT_MANAGER.md)
 
 > 🎉 **NEW: 100% Stats API Coverage** - All 14 Steam statistics functions implemented! [See Documentation](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/STATS_MANAGER.md)
 
 > 🎉 **NEW: 100% Leaderboard API Coverage** - All 7 Steam leaderboard functions implemented! [See Documentation](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/LEADERBOARD_MANAGER.md)
 
-> 🎉 **NEW: Friends API** - 10 essential Steam friends and social functions implemented! [See Documentation](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/FRIENDS_MANAGER.md)
+> 🎉 **NEW: Friends API** - 22 complete Steam friends and social functions implemented! [See Documentation](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/FRIENDS_MANAGER.md)
+
+> 🎉 **NEW: Rich Presence API** - 6 functions for custom status display and friend join functionality! [See Documentation](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/RICH_PRESENCE_MANAGER.md)
+
+> 🎉 **NEW: Overlay API** - 7 functions for complete Steam overlay control! [See Documentation](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/OVERLAY_MANAGER.md)
 
 ## 🎯 Features
 
@@ -33,11 +39,25 @@ A production-ready TypeScript/JavaScript wrapper for the Steamworks SDK using Ko
   - ✅ Score operations (upload with optional details)
   - ✅ Entry download (global, friends, specific users)
   - ✅ UGC integration (attach replays/screenshots to entries)
-- **Friends & Social API**: Essential Steam friends and social features (10 core functions)
+- **Friends & Social API**: Complete Steam friends and social features (22 functions)
   - ✅ Current user info (persona name, online state)
   - ✅ Friends list management (count, iterate, get all friends)
   - ✅ Friend information (names, states, relationships, Steam levels)
   - ✅ Friend activity (check games being played)
+  - ✅ Friend avatars (small/medium/large avatar handles)
+  - ✅ Friend groups (tags/categories management)
+  - ✅ Coplay tracking (recently played with users)
+- **Rich Presence API**: Complete Rich Presence support (6 functions)
+  - ✅ Set/clear rich presence key/value pairs
+  - ✅ Query friend rich presence data
+  - ✅ Display custom status in friends list
+  - ✅ Enable friend join functionality
+- **Overlay API**: Complete Steam overlay control (7 functions)
+  - ✅ Open overlay dialogs (friends, achievements, settings, etc.)
+  - ✅ Open user profiles, stats, and achievements
+  - ✅ Open overlay web browser to URLs
+  - ✅ Open store pages with purchase options
+  - ✅ Show invite dialogs for multiplayer sessions
 - **Steamworks Integration**: Direct FFI calls to Steamworks C++ SDK
 - **Cross-Platform**: Windows, macOS, and Linux support
 - **Batteries Included**: All Steamworks redistributables bundled - no SDK download needed!
@@ -133,12 +153,45 @@ if (initialized) {
     const level = steam.friends.getFriendSteamLevel(friend.steamId);
     console.log(`${name}: Level ${level}, Status: ${state}`);
     
+    // Get avatar handles
+    const smallAvatar = steam.friends.getSmallFriendAvatar(friend.steamId);
+    const mediumAvatar = steam.friends.getMediumFriendAvatar(friend.steamId);
+    if (smallAvatar > 0) {
+      console.log(`  Avatar handles: small=${smallAvatar}, medium=${mediumAvatar}`);
+    }
+    
     // Check if playing a game
     const gameInfo = steam.friends.getFriendGamePlayed(friend.steamId);
-    if (gameInfo.playing) {
-      console.log(`  Playing: ${gameInfo.gameName} (AppID: ${gameInfo.gameId})`);
+    if (gameInfo) {
+      console.log(`  Playing: App ${gameInfo.gameId}`);
     }
   });
+  
+  // Check friend groups (tags)
+  const groupCount = steam.friends.getFriendsGroupCount();
+  if (groupCount > 0) {
+    const groupId = steam.friends.getFriendsGroupIDByIndex(0);
+    const groupName = steam.friends.getFriendsGroupName(groupId);
+    const members = steam.friends.getFriendsGroupMembersList(groupId);
+    console.log(`Group "${groupName}" has ${members.length} members`);
+  }
+  
+  // Check recently played with
+  const coplayCount = steam.friends.getCoplayFriendCount();
+  if (coplayCount > 0) {
+    const recentPlayer = steam.friends.getCoplayFriend(0);
+    const playerName = steam.friends.getFriendPersonaName(recentPlayer);
+    const coplayTime = steam.friends.getFriendCoplayTime(recentPlayer);
+    console.log(`Recently played with ${playerName}`);
+  }
+  
+  // Set rich presence for custom status
+  steam.richPresence.setRichPresence('status', 'In Main Menu');
+  steam.richPresence.setRichPresence('connect', '+connect server:27015');
+  
+  // Open Steam overlay
+  steam.overlay.activateGameOverlay('Friends'); // Open friends list
+  steam.overlay.activateGameOverlayToWebPage('https://example.com/wiki'); // Open wiki
 }
 
 // Cleanup
@@ -187,7 +240,9 @@ Complete documentation for all APIs is available in the [docs folder](https://gi
 - **[Achievement Manager](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/ACHIEVEMENT_MANAGER.md)** - Complete achievement system (20 functions)
 - **[Stats Manager](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/STATS_MANAGER.md)** - User and global statistics (14 functions)
 - **[Leaderboard Manager](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/LEADERBOARD_MANAGER.md)** - Leaderboard operations (7 functions)
-- **[Friends Manager](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/FRIENDS_MANAGER.md)** - Friends and social features (10 functions)
+- **[Friends Manager](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/FRIENDS_MANAGER.md)** - Friends and social features (22 functions)
+- **[Rich Presence Manager](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/RICH_PRESENCE_MANAGER.md)** - Custom status display and join functionality (6 functions)
+- **[Overlay Manager](https://github.com/ArtyProf/steamworks-ffi-node/blob/main/docs/OVERLAY_MANAGER.md)** - Steam overlay control (7 functions)
 
 ## 🎮 Steamworks Integration
 
@@ -291,6 +346,8 @@ This ensures native libraries work correctly in packaged Electron apps!
 - ✅ **macOS**: Included (libsteam_api.dylib)
 - ✅ **Linux**: Included (libsteam_api.so)
 
+**Steamworks SDK Version**: v1.62 (Latest)
+
 All redistributable binaries are included in the package - no manual SDK download required!
 
 ## 🔧 Troubleshooting

package/dist/index.d.ts

@@ -2,6 +2,9 @@ import SteamworksSDK from './steam';
 export { SteamAchievementManager } from './internal/SteamAchievementManager';
 export { SteamStatsManager } from './internal/SteamStatsManager';
 export { SteamLeaderboardManager } from './internal/SteamLeaderboardManager';
+export { SteamFriendsManager } from './internal/SteamFriendsManager';
+export { SteamRichPresenceManager } from './internal/SteamRichPresenceManager';
+export { SteamOverlayManager } from './internal/SteamOverlayManager';
 export * from './types';
 export default SteamworksSDK;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,SAAS,CAAC;AAGpC,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAG7E,cAAc,SAAS,CAAC;AAGxB,eAAe,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,SAAS,CAAC;AAGpC,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,EAAE,wBAAwB,EAAE,MAAM,qCAAqC,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAGrE,cAAc,SAAS,CAAC;AAGxB,eAAe,aAAa,CAAC"}

package/dist/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SteamLeaderboardManager = exports.SteamStatsManager = exports.SteamAchievementManager = void 0;
+exports.SteamOverlayManager = exports.SteamRichPresenceManager = exports.SteamFriendsManager = exports.SteamLeaderboardManager = exports.SteamStatsManager = exports.SteamAchievementManager = void 0;
 const steam_1 = __importDefault(require("./steam"));
 // Export manager classes for advanced usage
 var SteamAchievementManager_1 = require("./internal/SteamAchievementManager");
@@ -26,6 +26,12 @@ var SteamStatsManager_1 = require("./internal/SteamStatsManager");
 Object.defineProperty(exports, "SteamStatsManager", { enumerable: true, get: function () { return SteamStatsManager_1.SteamStatsManager; } });
 var SteamLeaderboardManager_1 = require("./internal/SteamLeaderboardManager");
 Object.defineProperty(exports, "SteamLeaderboardManager", { enumerable: true, get: function () { return SteamLeaderboardManager_1.SteamLeaderboardManager; } });
+var SteamFriendsManager_1 = require("./internal/SteamFriendsManager");
+Object.defineProperty(exports, "SteamFriendsManager", { enumerable: true, get: function () { return SteamFriendsManager_1.SteamFriendsManager; } });
+var SteamRichPresenceManager_1 = require("./internal/SteamRichPresenceManager");
+Object.defineProperty(exports, "SteamRichPresenceManager", { enumerable: true, get: function () { return SteamRichPresenceManager_1.SteamRichPresenceManager; } });
+var SteamOverlayManager_1 = require("./internal/SteamOverlayManager");
+Object.defineProperty(exports, "SteamOverlayManager", { enumerable: true, get: function () { return SteamOverlayManager_1.SteamOverlayManager; } });
 // Export all types from organized structure
 __exportStar(require("./types"), exports);
 // Export main Steam class

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,oDAAoC;AAEpC,4CAA4C;AAC5C,8EAA6E;AAApE,kIAAA,uBAAuB,OAAA;AAChC,kEAAiE;AAAxD,sHAAA,iBAAiB,OAAA;AAC1B,8EAA6E;AAApE,kIAAA,uBAAuB,OAAA;AAEhC,4CAA4C;AAC5C,0CAAwB;AAExB,0BAA0B;AAC1B,kBAAe,eAAa,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,oDAAoC;AAEpC,4CAA4C;AAC5C,8EAA6E;AAApE,kIAAA,uBAAuB,OAAA;AAChC,kEAAiE;AAAxD,sHAAA,iBAAiB,OAAA;AAC1B,8EAA6E;AAApE,kIAAA,uBAAuB,OAAA;AAChC,sEAAqE;AAA5D,0HAAA,mBAAmB,OAAA;AAC5B,gFAA+E;AAAtE,oIAAA,wBAAwB,OAAA;AACjC,sEAAqE;AAA5D,0HAAA,mBAAmB,OAAA;AAE5B,4CAA4C;AAC5C,0CAAwB;AAExB,0BAA0B;AAC1B,kBAAe,eAAa,CAAC"}

package/dist/internal/SteamFriendsManager.d.ts

@@ -1,6 +1,6 @@
 import { SteamLibraryLoader } from './SteamLibraryLoader';
 import { SteamAPICore } from './SteamAPICore';
-import { EFriendRelationship, EPersonaState, EFriendFlags, FriendInfo, FriendGameInfo } from '../types';
+import { EFriendRelationship, EPersonaState, EFriendFlags, FriendInfo, FriendGameInfo, FriendsGroupID_t } from '../types';
 /**
  * Manager for Steam Friends API operations
  *
@@ -361,5 +361,372 @@ export declare class SteamFriendsManager {
      * @see {@link FriendGameInfo}
      */
     getFriendGamePlayed(steamId: string): FriendGameInfo | null;
+    /**
+     * Gets the handle for a friend's small (32x32) avatar image
+     *
+     * @param steamId - The friend's Steam ID as a string
+     * @returns Image handle for use with ISteamUtils, or 0 if unavailable
+     *
+     * @remarks
+     * This returns a handle that can be used with ISteamUtils::GetImageSize()
+     * and ISteamUtils::GetImageRGBA() to retrieve the actual image data.
+     *
+     * Small avatars are 32x32 pixels and are suitable for:
+     * - Friend list thumbnails
+     * - Chat message icons
+     * - Compact UI elements
+     *
+     * The avatar image is cached by Steam. If it returns 0, the image might
+     * still be loading. You can try again after a short delay.
+     *
+     * @example
+     * ```typescript
+     * const avatarHandle = steam.friends.getSmallFriendAvatar(friendSteamId);
+     * if (avatarHandle > 0) {
+     *   console.log(`Small avatar handle: ${avatarHandle}`);
+     *   // Use with ISteamUtils to get actual image data
+     * }
+     * ```
+     *
+     * @see {@link getMediumFriendAvatar}
+     * @see {@link getLargeFriendAvatar}
+     */
+    getSmallFriendAvatar(steamId: string): number;
+    /**
+     * Gets the handle for a friend's medium (64x64) avatar image
+     *
+     * @param steamId - The friend's Steam ID as a string
+     * @returns Image handle for use with ISteamUtils, or 0 if unavailable
+     *
+     * @remarks
+     * This returns a handle that can be used with ISteamUtils::GetImageSize()
+     * and ISteamUtils::GetImageRGBA() to retrieve the actual image data.
+     *
+     * Medium avatars are 64x64 pixels and are suitable for:
+     * - User profiles
+     * - Game lobby player lists
+     * - Standard UI elements
+     *
+     * The avatar image is cached by Steam. If it returns 0, the image might
+     * still be loading. You can try again after a short delay.
+     *
+     * @example
+     * ```typescript
+     * const avatarHandle = steam.friends.getMediumFriendAvatar(friendSteamId);
+     * if (avatarHandle > 0) {
+     *   console.log(`Medium avatar handle: ${avatarHandle}`);
+     *   // Use with ISteamUtils to get actual image data
+     * }
+     * ```
+     *
+     * @see {@link getSmallFriendAvatar}
+     * @see {@link getLargeFriendAvatar}
+     */
+    getMediumFriendAvatar(steamId: string): number;
+    /**
+     * Gets the handle for a friend's large (184x184) avatar image
+     *
+     * @param steamId - The friend's Steam ID as a string
+     * @returns Image handle for use with ISteamUtils, or 0 if unavailable
+     *
+     * @remarks
+     * This returns a handle that can be used with ISteamUtils::GetImageSize()
+     * and ISteamUtils::GetImageRGBA() to retrieve the actual image data.
+     *
+     * Large avatars are 184x184 pixels and are suitable for:
+     * - Detailed profile views
+     * - Full-screen overlays
+     * - High-resolution displays
+     *
+     * The avatar image is cached by Steam. If it returns 0, the image might
+     * still be loading. You can try again after a short delay.
+     *
+     * @example
+     * ```typescript
+     * const avatarHandle = steam.friends.getLargeFriendAvatar(friendSteamId);
+     * if (avatarHandle > 0) {
+     *   console.log(`Large avatar handle: ${avatarHandle}`);
+     *   // Use with ISteamUtils to get actual image data
+     * }
+     * ```
+     *
+     * @see {@link getSmallFriendAvatar}
+     * @see {@link getMediumFriendAvatar}
+     */
+    getLargeFriendAvatar(steamId: string): number;
+    /**
+     * Gets the number of Steam friend groups (tags) the user has created
+     *
+     * @returns The number of friend groups, or 0 if unavailable
+     *
+     * @remarks
+     * Steam allows users to organize friends into custom groups (also called tags).
+     * This returns the total number of groups the current user has created.
+     *
+     * Use this with {@link getFriendsGroupIDByIndex} to iterate through all groups.
+     *
+     * @example
+     * ```typescript
+     * const groupCount = steam.friends.getFriendsGroupCount();
+     * console.log(`You have ${groupCount} friend groups`);
+     *
+     * for (let i = 0; i < groupCount; i++) {
+     *   const groupId = steam.friends.getFriendsGroupIDByIndex(i);
+     *   const groupName = steam.friends.getFriendsGroupName(groupId);
+     *   console.log(`Group ${i}: ${groupName}`);
+     * }
+     * ```
+     *
+     * @see {@link getFriendsGroupIDByIndex}
+     * @see {@link getFriendsGroupName}
+     */
+    getFriendsGroupCount(): number;
+    /**
+     * Gets a friend group ID by its index
+     *
+     * @param index - Zero-based index of the group (0 to {@link getFriendsGroupCount}() - 1)
+     * @returns The group ID, or {@link INVALID_FRIENDS_GROUP_ID} if the index is invalid
+     *
+     * @remarks
+     * Use this method to iterate through all friend groups:
+     * 1. Call {@link getFriendsGroupCount} to get the total number of groups
+     * 2. Loop from 0 to count-1 calling this method to get each group ID
+     * 3. Use the returned ID with {@link getFriendsGroupName} and {@link getFriendsGroupMembersList}
+     *
+     * @example
+     * ```typescript
+     * const groupCount = steam.friends.getFriendsGroupCount();
+     * for (let i = 0; i < groupCount; i++) {
+     *   const groupId = steam.friends.getFriendsGroupIDByIndex(i);
+     *   if (groupId !== INVALID_FRIENDS_GROUP_ID) {
+     *     const name = steam.friends.getFriendsGroupName(groupId);
+     *     const memberCount = steam.friends.getFriendsGroupMembersCount(groupId);
+     *     console.log(`Group: ${name} (${memberCount} members)`);
+     *   }
+     * }
+     * ```
+     *
+     * @see {@link getFriendsGroupCount}
+     * @see {@link getFriendsGroupName}
+     * @see {@link INVALID_FRIENDS_GROUP_ID}
+     */
+    getFriendsGroupIDByIndex(index: number): FriendsGroupID_t;
+    /**
+     * Gets the name of a friend group
+     *
+     * @param groupId - The ID of the friend group
+     * @returns The group name, or empty string if unavailable
+     *
+     * @remarks
+     * Returns the user-defined name for the specified friend group.
+     * Group names are created and managed by the user in the Steam client.
+     *
+     * @example
+     * ```typescript
+     * const groupId = steam.friends.getFriendsGroupIDByIndex(0);
+     * if (groupId !== INVALID_FRIENDS_GROUP_ID) {
+     *   const name = steam.friends.getFriendsGroupName(groupId);
+     *   console.log(`First group is named: ${name}`);
+     * }
+     * ```
+     *
+     * @see {@link getFriendsGroupIDByIndex}
+     * @see {@link getFriendsGroupMembersCount}
+     */
+    getFriendsGroupName(groupId: FriendsGroupID_t): string;
+    /**
+     * Gets the number of members in a friend group
+     *
+     * @param groupId - The ID of the friend group
+     * @returns The number of friends in the group, or 0 if unavailable
+     *
+     * @remarks
+     * Returns how many friends are assigned to the specified group.
+     * Use this with {@link getFriendsGroupMembersList} to retrieve the actual members.
+     *
+     * @example
+     * ```typescript
+     * const groupId = steam.friends.getFriendsGroupIDByIndex(0);
+     * const memberCount = steam.friends.getFriendsGroupMembersCount(groupId);
+     * console.log(`Group has ${memberCount} members`);
+     * ```
+     *
+     * @see {@link getFriendsGroupMembersList}
+     * @see {@link getFriendsGroupName}
+     */
+    getFriendsGroupMembersCount(groupId: FriendsGroupID_t): number;
+    /**
+     * Gets the list of Steam IDs for all members in a friend group
+     *
+     * @param groupId - The ID of the friend group
+     * @returns Array of Steam IDs (as strings) of friends in the group
+     *
+     * @remarks
+     * Returns an array containing the Steam ID of each friend assigned to this group.
+     * The array will be empty if the group has no members or if an error occurs.
+     *
+     * This method allocates memory for the maximum possible members and then
+     * populates it with the actual members. The returned array only contains
+     * the actual members, not the full allocated buffer.
+     *
+     * @example
+     * ```typescript
+     * const groupId = steam.friends.getFriendsGroupIDByIndex(0);
+     * const groupName = steam.friends.getFriendsGroupName(groupId);
+     * const members = steam.friends.getFriendsGroupMembersList(groupId);
+     *
+     * console.log(`Group "${groupName}" has ${members.length} members:`);
+     * members.forEach(steamId => {
+     *   const name = steam.friends.getFriendPersonaName(steamId);
+     *   console.log(`  - ${name} (${steamId})`);
+     * });
+     * ```
+     *
+     * @see {@link getFriendsGroupMembersCount}
+     * @see {@link getFriendsGroupName}
+     */
+    getFriendsGroupMembersList(groupId: FriendsGroupID_t): string[];
+    /**
+     * Gets the number of users the current user has recently played with
+     *
+     * @returns The number of coplay friends, or 0 if unavailable
+     *
+     * @remarks
+     * "Coplay" refers to users you've recently been in multiplayer games with.
+     * Steam tracks these relationships automatically when you play games together.
+     *
+     * Use this with {@link getCoplayFriend} to iterate through all coplay friends.
+     *
+     * @example
+     * ```typescript
+     * const coplayCount = steam.friends.getCoplayFriendCount();
+     * console.log(`You've recently played with ${coplayCount} users`);
+     *
+     * for (let i = 0; i < coplayCount; i++) {
+     *   const steamId = steam.friends.getCoplayFriend(i);
+     *   const name = steam.friends.getFriendPersonaName(steamId);
+     *   const time = steam.friends.getFriendCoplayTime(steamId);
+     *   console.log(`Played with ${name} at ${new Date(time * 1000)}`);
+     * }
+     * ```
+     *
+     * @see {@link getCoplayFriend}
+     * @see {@link getFriendCoplayTime}
+     * @see {@link getFriendCoplayGame}
+     */
+    getCoplayFriendCount(): number;
+    /**
+     * Gets a coplay friend's Steam ID by their index
+     *
+     * @param index - Zero-based index of the coplay friend (0 to {@link getCoplayFriendCount}() - 1)
+     * @returns The friend's Steam ID as a string, or empty string if the index is invalid
+     *
+     * @remarks
+     * Use this method to iterate through all users you've recently played with:
+     * 1. Call {@link getCoplayFriendCount} to get the total number
+     * 2. Loop from 0 to count-1 calling this method to get each Steam ID
+     * 3. Use the returned ID with {@link getFriendCoplayTime} and {@link getFriendCoplayGame}
+     *
+     * @example
+     * ```typescript
+     * const count = steam.friends.getCoplayFriendCount();
+     * for (let i = 0; i < count; i++) {
+     *   const steamId = steam.friends.getCoplayFriend(i);
+     *   if (steamId) {
+     *     const name = steam.friends.getFriendPersonaName(steamId);
+     *     const appId = steam.friends.getFriendCoplayGame(steamId);
+     *     console.log(`Played with ${name} in app ${appId}`);
+     *   }
+     * }
+     * ```
+     *
+     * @see {@link getCoplayFriendCount}
+     * @see {@link getFriendCoplayTime}
+     */
+    getCoplayFriend(index: number): string;
+    /**
+     * Gets the last time you played with a specific user
+     *
+     * @param steamId - The friend's Steam ID as a string
+     * @returns Unix timestamp of when you last played together, or 0 if never/unavailable
+     *
+     * @remarks
+     * Returns the Unix timestamp (seconds since January 1, 1970) of the most recent
+     * time you were in a multiplayer game with this user.
+     *
+     * Returns 0 if:
+     * - You've never played with this user
+     * - The information is not available
+     * - The Steam API is not initialized
+     *
+     * @example
+     * ```typescript
+     * const steamId = steam.friends.getCoplayFriend(0);
+     * const timestamp = steam.friends.getFriendCoplayTime(steamId);
+     *
+     * if (timestamp > 0) {
+     *   const date = new Date(timestamp * 1000);
+     *   console.log(`Last played together on: ${date.toLocaleDateString()}`);
+     * }
+     * ```
+     *
+     * @see {@link getCoplayFriend}
+     * @see {@link getFriendCoplayGame}
+     */
+    getFriendCoplayTime(steamId: string): number;
+    /**
+     * Gets the App ID of the game you last played with a specific user
+     *
+     * @param steamId - The friend's Steam ID as a string
+     * @returns The Steam App ID of the game, or 0 if never/unavailable
+     *
+     * @remarks
+     * Returns the Steam App ID of the game you most recently played together with this user.
+     *
+     * Returns 0 if:
+     * - You've never played with this user
+     * - The information is not available
+     * - The Steam API is not initialized
+     *
+     * @example
+     * ```typescript
+     * const count = steam.friends.getCoplayFriendCount();
+     * for (let i = 0; i < count; i++) {
+     *   const steamId = steam.friends.getCoplayFriend(i);
+     *   const name = steam.friends.getFriendPersonaName(steamId);
+     *   const appId = steam.friends.getFriendCoplayGame(steamId);
+     *   const time = steam.friends.getFriendCoplayTime(steamId);
+     *
+     *   console.log(`Played with ${name} in App ${appId}`);
+     *   console.log(`Last played: ${new Date(time * 1000).toLocaleDateString()}`);
+     * }
+     * ```
+     *
+     * @example Get all coplay information
+     * ```typescript
+     * function getAllCoplayInfo(): CoplayFriendInfo[] {
+     *   const count = steam.friends.getCoplayFriendCount();
+     *   const coplayFriends: CoplayFriendInfo[] = [];
+     *
+     *   for (let i = 0; i < count; i++) {
+     *     const steamId = steam.friends.getCoplayFriend(i);
+     *     if (steamId) {
+     *       coplayFriends.push({
+     *         steamId,
+     *         coplayTime: steam.friends.getFriendCoplayTime(steamId),
+     *         coplayGame: steam.friends.getFriendCoplayGame(steamId)
+     *       });
+     *     }
+     *   }
+     *
+     *   return coplayFriends;
+     * }
+     * ```
+     *
+     * @see {@link getCoplayFriend}
+     * @see {@link getFriendCoplayTime}
+     * @see {@link CoplayFriendInfo}
+     */
+    getFriendCoplayGame(steamId: string): number;
 }
 //# sourceMappingURL=SteamFriendsManager.d.ts.map

package/dist/internal/SteamFriendsManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SteamFriendsManager.d.ts","sourceRoot":"","sources":["../../src/internal/SteamFriendsManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EACL,mBAAmB,EACnB,aAAa,EACb,YAAY,EACZ,UAAU,EACV,cAAc,EACf,MAAM,UAAU,CAAC;AAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,qBAAa,mBAAmB;IAC9B,kDAAkD;IAClD,OAAO,CAAC,aAAa,CAAqB;IAE1C,gEAAgE;IAChE,OAAO,CAAC,OAAO,CAAe;IAE9B,mDAAmD;IACnD,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAM5B;IAEH;;;;;OAKG;gBACS,aAAa,EAAE,kBAAkB,EAAE,OAAO,EAAE,YAAY;IAKpE;;;;;;;;;;;;;;OAcG;IACH,cAAc,IAAI,MAAM;IAqBxB;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,eAAe,IAAI,aAAa;IAqBhC;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAAc,CAAC,WAAW,GAAE,YAAqC,GAAG,MAAM;IAqB1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,GAAE,YAAqC,GAAG,MAAM,GAAG,IAAI;IA2BlG;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAqB7C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa;IAqBrD;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,mBAAmB;IAqB3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACH,aAAa,CAAC,WAAW,GAAE,YAAqC,GAAG,UAAU,EAAE;IAoB/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAqB5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;CAyC5D"}
+{"version":3,"file":"SteamFriendsManager.d.ts","sourceRoot":"","sources":["../../src/internal/SteamFriendsManager.ts"],"names":[],"mappings":"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"}