Started working on a Steam library

OmegaLeo.HelperLib.ConsoleApp/Program.cs

@@ -32,6 +32,85 @@ public class Program
             steamLogger.LogInformation("Welcome {SteamName}", steam.GetSteamName());
         }
 
+        steamLogger.LogInformation("--- Steam wrapper smoke tests ---");
+
+        // Utils (read-only)
+        steamLogger.LogInformation("Utils available: {Available}", steam.Utils.IsAvailable);
+        if (steam.Utils.IsAvailable)
+        {
+            steamLogger.LogInformation("AppId: {AppId}, Country: {Country}, Overlay: {Overlay}",
+                steam.Utils.GetAppId(),
+                steam.Utils.GetIpCountry(),
+                steam.Utils.IsOverlayEnabled());
+        }
+
+        // Friends (read-only)
+        steamLogger.LogInformation("Friends available: {Available}", steam.Friends.IsAvailable);
+        if (steam.Friends.IsAvailable)
+        {
+            // 65535 tests all friend relationship flags for quick smoke coverage.
+            var friendCount = steam.Friends.GetFriendCount(65535);
+            steamLogger.LogInformation("Friend count (all flags): {FriendCount}", friendCount);
+        }
+
+        // Remote storage (read-only)
+        steamLogger.LogInformation("RemoteStorage available: {Available}", steam.RemoteStorage.IsAvailable);
+        if (steam.RemoteStorage.IsAvailable)
+        {
+            steamLogger.LogInformation("Cloud enabled: {Enabled}, file count: {Count}",
+                steam.RemoteStorage.IsCloudEnabledForApp(),
+                steam.RemoteStorage.GetFileCount());
+        }
+
+        // User stats (safe read/request)
+        steamLogger.LogInformation("UserStats available: {Available}", steam.UserStats.IsAvailable);
+        if (steam.UserStats.IsAvailable)
+        {
+            var globalStatsCall = steam.UserStats.RequestGlobalStats(7);
+            steamLogger.LogInformation("RequestGlobalStats call handle: {Handle}", globalStatsCall);
+        }
+
+        // UGC (safe query/subscription read)
+        steamLogger.LogInformation("UGC subscribed count: {Count}", steam.Ugc.GetNumSubscribedItems());
+        var ugcQuery = steam.Ugc.CreateQueryAllUgcRequest(queryType: 0, matchingType: 0, creatorAppId: 480, consumerAppId: 480, page: 1);
+        if (ugcQuery != 0)
+        {
+            var ugcCall = steam.Ugc.SendQueryUgcRequest(ugcQuery);
+            steamLogger.LogInformation("UGC query handle: {QueryHandle}, call handle: {CallHandle}", ugcQuery, ugcCall);
+            steam.Ugc.ReleaseQueryUgcRequest(ugcQuery);
+        }
+        else
+        {
+            steamLogger.LogWarning("UGC query handle returned 0 (unsupported on this runtime or invalid params).");
+        }
+
+        // Matchmaking (safe request)
+        steamLogger.LogInformation("Matchmaking available: {Available}", steam.Matchmaking.IsAvailable);
+        if (steam.Matchmaking.IsAvailable)
+        {
+            steam.Matchmaking.AddRequestLobbyListResultCountFilter(10);
+            var lobbyListCall = steam.Matchmaking.RequestLobbyList();
+            steamLogger.LogInformation("RequestLobbyList call handle: {Handle}", lobbyListCall);
+        }
+
+        // Remote Play
+        steamLogger.LogInformation("RemotePlay sessions: {SessionCount}", steam.RemotePlay.GetSessionCount());
+
+        // Other read-only status checks
+        steamLogger.LogInformation("Screenshots hooked: {Hooked}", steam.Screenshots.IsScreenshotsHooked());
+        steamLogger.LogInformation("Music enabled: {Enabled}, playing: {Playing}, volume: {Volume}",
+            steam.Music.IsEnabled(), steam.Music.IsPlaying(), steam.Music.GetVolume());
+        if (steam.Video.IsBroadcasting(out var viewers))
+        {
+            steamLogger.LogInformation("Video broadcasting viewers: {Viewers}", viewers);
+        }
+        else
+        {
+            steamLogger.LogInformation("Video broadcasting is not active.");
+        }
+
+        steamLogger.LogInformation("--- End smoke tests ---");
+
         // Call this in your game loop (Unity Update, Godot _Process, etc.)
         steam.Update();
 

OmegaLeo.HelperLib.Documentation/Helpers/DocumentationHelper.cs

@@ -12,6 +12,7 @@ namespace OmegaLeo.HelperLib.Documentation.Helpers
 {
 
     [Changelog("1.2.0", "Migrated DocumentationHelper library from NetFlow.DocumentationHelper.Library to it's own package in OmegaLeo.HelperLib", "January 26, 2026")]
+    [Changelog("1.3.0", "GenerateDocumentation now includes method parameters and return type in the generated documentation", "April 14, 2026")]
     public static class DocumentationHelperTool
     {
         [Documentation("GenerateDocumentation (bool generateForPackageAssembly)",
@@ -21,6 +22,8 @@ namespace OmegaLeo.HelperLib.Documentation.Helpers
 **Title**: Title what we're generating documentation for  
 **Description**: Description of what we're generating documentation for, this can contain usage examples and can use the args array to pass names(e.g.: This method uses this methodology)  
 **Args**: Array of strings that describe the parameters of the method or class  
+**MethodParameters**: Reflected parameter signature list for documented methods (e.g. `value: int`, `name: string`)  
+**ReturnType**: Reflected return type for documented methods (e.g. `bool`, `List<string>`)  
 **CodeExample**: A code example of how to use the method or class  
   
 *Note: If generateForPackageAssembly is set to true, this will generate documentation for the library as well.*",
@@ -146,7 +149,12 @@ DocumentationHelperTool.GenerateDocumentation(false); // Generates documentation
             var propertyDocs = type.GetProperties().SelectMany(p =>
                 p.GetCustomAttributes(typeof(DocumentationAttribute), true).Select(x => (DocumentationAttribute)x));
             var methodDocs = type.GetMethods().SelectMany(m =>
-                m.GetCustomAttributes(typeof(DocumentationAttribute), true).Select(x => (DocumentationAttribute)x));
+                m.GetCustomAttributes(typeof(DocumentationAttribute), true)
+                    .Select(x => new
+                    {
+                        Method = m,
+                        Attribute = (DocumentationAttribute)x
+                    }));
             
             var docStructure = new DocumentationStructure(assemblyName, type.Name);
 
@@ -165,14 +173,95 @@ DocumentationHelperTool.GenerateDocumentation(false); // Generates documentation
                 docStructure.AddDescription(new DocumentationDescription(doc.Title, doc.Description, doc.Args, doc.CodeExample));
             }
 
-            foreach (var doc in methodDocs)
+            foreach (var methodDoc in methodDocs)
             {
-                docStructure.AddDescription(new DocumentationDescription(doc.Title, doc.Description, doc.Args, doc.CodeExample));
+                var reflectedParameters = GetMethodParameters(methodDoc.Method);
+                var returnType = GetFriendlyTypeName(methodDoc.Method.ReturnType);
+
+                var mergedParameters = (methodDoc.Attribute.Args ?? Array.Empty<string>())
+                    .Concat(reflectedParameters)
+                    .ToArray();
+
+                docStructure.AddDescription(new DocumentationDescription(
+                    methodDoc.Attribute.Title,
+                    methodDoc.Attribute.Description,
+                    mergedParameters,
+                    methodDoc.Attribute.CodeExample,
+                    reflectedParameters,
+                    returnType));
             }
 
             return docStructure;
         }
 
+        static string[] GetMethodParameters(MethodInfo method)
+        {
+            return method.GetParameters()
+                .Select(parameter =>
+                {
+                    var prefix = parameter.IsOut
+                        ? "out "
+                        : parameter.ParameterType.IsByRef
+                            ? "ref "
+                            : string.Empty;
+
+                    var parameterType = parameter.ParameterType.IsByRef
+                        ? parameter.ParameterType.GetElementType() ?? parameter.ParameterType
+                        : parameter.ParameterType;
+
+                    return $"{parameter.Name}: {prefix}{GetFriendlyTypeName(parameterType)}";
+                })
+                .ToArray();
+        }
+
+        static string GetFriendlyTypeName(Type type)
+        {
+            if (type == typeof(void)) return "void";
+            if (type == typeof(bool)) return "bool";
+            if (type == typeof(byte)) return "byte";
+            if (type == typeof(sbyte)) return "sbyte";
+            if (type == typeof(char)) return "char";
+            if (type == typeof(decimal)) return "decimal";
+            if (type == typeof(double)) return "double";
+            if (type == typeof(float)) return "float";
+            if (type == typeof(int)) return "int";
+            if (type == typeof(uint)) return "uint";
+            if (type == typeof(long)) return "long";
+            if (type == typeof(ulong)) return "ulong";
+            if (type == typeof(short)) return "short";
+            if (type == typeof(ushort)) return "ushort";
+            if (type == typeof(string)) return "string";
+            if (type == typeof(object)) return "object";
+
+            if (type.IsArray)
+            {
+                return $"{GetFriendlyTypeName(type.GetElementType() ?? typeof(object))}[]";
+            }
+
+            if (type.IsGenericType)
+            {
+                var name = type.Name;
+                var tickIndex = name.IndexOf('`');
+                if (tickIndex > 0)
+                {
+                    name = name.Substring(0, tickIndex);
+                }
+
+                var genericArguments = type.GetGenericArguments()
+                    .Select(GetFriendlyTypeName);
+
+                return $"{name}<{string.Join(", ", genericArguments)}>";
+            }
+
+            var nullable = Nullable.GetUnderlyingType(type);
+            if (nullable != null)
+            {
+                return $"{GetFriendlyTypeName(nullable)}?";
+            }
+
+            return type.Name;
+        }
+        
         static Dictionary<string, string> loadedXmlDocumentation =
             new Dictionary<string, string>();
         public static void LoadXmlDocumentation(string xmlDocumentation)

OmegaLeo.HelperLib.Documentation/Models/DocumentationStructure.cs

@@ -29,6 +29,8 @@ namespace OmegaLeo.HelperLib.Documentation.Models
         public string Title;
         public string Description;
         public string[] Parameters;
+        public string[] MethodParameters;
+        public string ReturnType;
         public string CodeExample = string.Empty;
 
         [Documentation(nameof(DocumentationDescription), "Description of the current Documented object", new []
@@ -36,13 +38,17 @@ namespace OmegaLeo.HelperLib.Documentation.Models
             "title - Name of the object",
             "description - Description of what the object does",
             "parameters - The parameters for the object (in case of a method with parameters)",
+            "methodParameters - Reflected method parameter list when the documented member is a method",
+            "returnType - Reflected return type when the documented member is a method",
             "codeExample - Code example of how to use the object"
         })]
-        public DocumentationDescription(string title, string description, string[] parameters = default, string codeExample = "")
+        public DocumentationDescription(string title, string description, string[]? parameters = null, string codeExample = "", string[]? methodParameters = null, string returnType = "")
         {
             Title = title;
             Description = description;
             Parameters = parameters ?? Array.Empty<string>();
+            MethodParameters = methodParameters ?? Array.Empty<string>();
+            ReturnType = returnType ?? string.Empty;
             CodeExample = codeExample;
         }
     }

OmegaLeo.HelperLib.Steamworks/README.md

@@ -9,6 +9,9 @@ This package provides a simple Steam API wrapper for common tasks like initializ
 - Safe shutdown with `SteamManager.Shutdown()`
 - Player persona name access with `SteamManager.GetSteamName()`
 - Achievement helpers via `AchievementManager`
+- Steam Workshop (UGC) helpers via `SteamManager.Instance.Ugc`
+- Steam Remote Play helpers via `SteamManager.Instance.RemotePlay`
+- Additional interface managers: Controller, Friends, GameServer, Input, Inventory, Matchmaking, Parties, RemoteStorage, Screenshots, UserStats, Utils, Video, and more.
 - Includes native Steam runtime files in NuGet package `runtimes/`
 
 ## Installation
@@ -35,9 +38,59 @@ steam.Update();
 var achievements = new AchievementManager();
 achievements.UnlockAchievement("ACH_FIRST_WIN");
 
+// Steam Workshop (UGC) example
+var subscribedIds = steam.Ugc.GetSubscribedItems();
+
+// Steam Remote Play example
+var remotePlaySessionCount = steam.RemotePlay.GetSessionCount();
+
 steam.Shutdown();
 ```
 
+## More API Examples
+```cs
+var steam = SteamManager.Instance;
+
+// Friends / rich presence
+steam.Friends.SetRichPresence("status", "In Match");
+steam.Friends.SetRichPresence("map", "Arena_01");
+var friendName = steam.Friends.GetFriendPersonaName(76561198000000000UL);
+var friendStatus = steam.Friends.GetFriendRichPresence(76561198000000000UL, "status");
+
+// Remote storage
+var saveBytes = System.Text.Encoding.UTF8.GetBytes("save-data-v1");
+steam.RemoteStorage.FileWrite("save_slot_1.dat", saveBytes);
+if (steam.RemoteStorage.FileRead("save_slot_1.dat", out var loadedBytes))
+{
+    var loadedText = System.Text.Encoding.UTF8.GetString(loadedBytes);
+}
+
+// User stats
+steam.UserStats.SetStatInt32("KILLS", 25);
+steam.UserStats.StoreStats();
+steam.UserStats.RequestGlobalStats(7);
+
+// UGC update convenience APIs (existing item)
+var options = new SteamUgcItemUpdateOptions
+{
+    Title = "My Workshop Item",
+    Description = "Updated description.",
+    Tags = new[] { "map", "coop" },
+    ContentFolder = "/absolute/path/to/content",
+    PreviewFile = "/absolute/path/to/preview.png"
+};
+var submitCallHandle = steam.Ugc.UpdateItem(480, 123456789012345678UL, options, "Updated content", out var failedStep);
+
+// Fluent session alternative
+var session = steam.Ugc.BeginUpdateSession(480, 123456789012345678UL)
+    .WithTitle("My Workshop Item")
+    .WithDescription("Updated description")
+    .WithTags("map", "coop")
+    .WithContentFolder("/absolute/path/to/content")
+    .WithPreviewFile("/absolute/path/to/preview.png");
+var submitCallHandle2 = session.Submit("Updated content", out var failedStep2);
+```
+
 ## Notes
 - Steam must be running and your app must be launched in a valid Steam context.
 - Configure your AppId before first access to `SteamManager.Instance`.

OmegaLeo.HelperLib.Steamworks/SteamExtendedManagers.cs

@@ -0,0 +1,401 @@
+using OmegaLeo.HelperLib.Shared.Attributes;
+
+namespace OmegaLeo.HelperLib.Steamworks
+{
+    [Documentation(nameof(SteamControllerManager), "Provides access checks for ISteamController.", null, null)]
+    public class SteamControllerManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamControllerAvailable();
+    }
+
+    [Documentation(nameof(SteamFriendsManager), "Provides access checks for ISteamFriends.", null, null)]
+    public class SteamFriendsManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamFriendsAvailable();
+
+        [Documentation(nameof(GetFriendCount), "Gets the friend count filtered by Steam friend flags.", new[] { "friendFlags: Bitmask value matching Steam EFriendFlags." }, null)]
+        public int GetFriendCount(int friendFlags)
+        {
+            return SteamNativeApi.GetFriendCount(friendFlags);
+        }
+
+        [Documentation(nameof(GetFriendPersonaName), "Gets the persona name of a friend by SteamID64.", new[] { "steamIdFriend: Friend SteamID64." }, null)]
+        public string GetFriendPersonaName(ulong steamIdFriend)
+        {
+            return SteamNativeApi.GetFriendPersonaName(steamIdFriend);
+        }
+
+        [Documentation(nameof(ActivateGameOverlayInviteDialog), "Opens the Steam invite dialog for a lobby.", new[] { "steamIdLobby: Lobby SteamID64." }, null)]
+        public void ActivateGameOverlayInviteDialog(ulong steamIdLobby)
+        {
+            SteamNativeApi.FriendsActivateGameOverlayInviteDialog(steamIdLobby);
+        }
+
+        [Documentation(nameof(SetRichPresence), "Sets a rich presence key/value pair for the local user.", new[] { "key: Rich presence key.", "value: Rich presence value." }, null)]
+        public bool SetRichPresence(string key, string value)
+        {
+            return SteamNativeApi.FriendsSetRichPresence(key, value);
+        }
+
+        [Documentation(nameof(ClearRichPresence), "Clears all rich presence values for the local user.", null, null)]
+        public void ClearRichPresence()
+        {
+            SteamNativeApi.FriendsClearRichPresence();
+        }
+
+        [Documentation(nameof(GetFriendRichPresence), "Gets a rich presence value for a specific friend.", new[] { "steamIdFriend: Friend SteamID64.", "key: Rich presence key." }, null)]
+        public string GetFriendRichPresence(ulong steamIdFriend, string key)
+        {
+            return SteamNativeApi.FriendsGetFriendRichPresence(steamIdFriend, key);
+        }
+
+        [Documentation(nameof(InviteUserToGame), "Invites a friend to the current game session using a connect string.", new[] { "steamIdFriend: Friend SteamID64.", "connectString: Game connect string passed through Steam invite." }, null)]
+        public bool InviteUserToGame(ulong steamIdFriend, string connectString)
+        {
+            return SteamNativeApi.FriendsInviteUserToGame(steamIdFriend, connectString);
+        }
+    }
+
+    [Documentation(nameof(SteamGameCoordinatorManager), "Provides access checks for ISteamGameCoordinator.", null, null)]
+    public class SteamGameCoordinatorManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamGameCoordinatorAvailable();
+    }
+
+    [Documentation(nameof(SteamGameServerManager), "Provides access checks for ISteamGameServer.", null, null)]
+    public class SteamGameServerManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamGameServerAvailable();
+    }
+
+    [Documentation(nameof(SteamGameServerStatsManager), "Provides access checks for ISteamGameServerStats.", null, null)]
+    public class SteamGameServerStatsManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamGameServerStatsAvailable();
+    }
+
+    [Documentation(nameof(SteamHtmlSurfaceManager), "Provides access checks for ISteamHTMLSurface.", null, null)]
+    public class SteamHtmlSurfaceManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamHtmlSurfaceAvailable();
+    }
+
+    [Documentation(nameof(SteamInputManager), "Provides access checks for ISteamInput.", null, null)]
+    public class SteamInputManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamInputAvailable();
+
+        [Documentation(nameof(Init), "Initializes Steam Input for the application.", new[] { "explicitlyCallRunFrame: Set true when your game will manually call RunFrame each frame." }, null)]
+        public bool Init(bool explicitlyCallRunFrame = false)
+        {
+            return SteamNativeApi.InputInit(explicitlyCallRunFrame);
+        }
+
+        [Documentation(nameof(Shutdown), "Shuts down Steam Input.", null, null)]
+        public bool Shutdown()
+        {
+            return SteamNativeApi.InputShutdown();
+        }
+
+        [Documentation(nameof(RunFrame), "Runs a Steam Input frame update.", null, null)]
+        public void RunFrame()
+        {
+            SteamNativeApi.InputRunFrame();
+        }
+    }
+
+    [Documentation(nameof(SteamInventoryManager), "Provides access checks for ISteamInventory.", null, null)]
+    public class SteamInventoryManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamInventoryAvailable();
+
+        [Documentation(nameof(LoadItemDefinitions), "Requests latest inventory item definitions from Steam.", null, null)]
+        public bool LoadItemDefinitions()
+        {
+            return SteamNativeApi.InventoryLoadItemDefinitions();
+        }
+
+        [Documentation(nameof(GetAllItems), "Requests all inventory items and returns a result handle.", new[] { "inventoryResultHandle: Inventory result handle to use with additional inventory API calls." }, null)]
+        public bool GetAllItems(out int inventoryResultHandle)
+        {
+            return SteamNativeApi.InventoryGetAllItems(out inventoryResultHandle);
+        }
+
+        [Documentation(nameof(DestroyResult), "Releases an inventory result handle returned from Steam Inventory API calls.", new[] { "inventoryResultHandle: Inventory result handle to release." }, null)]
+        public void DestroyResult(int inventoryResultHandle)
+        {
+            SteamNativeApi.InventoryDestroyResult(inventoryResultHandle);
+        }
+    }
+
+    [Documentation(nameof(SteamMatchmakingManager), "Provides access checks for ISteamMatchmaking.", null, null)]
+    public class SteamMatchmakingManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamMatchmakingAvailable();
+
+        [Documentation(nameof(RequestLobbyList), "Requests a lobby list and returns a Steam API call handle.", null, null)]
+        public ulong RequestLobbyList()
+        {
+            return SteamNativeApi.MatchmakingRequestLobbyList();
+        }
+
+        [Documentation(nameof(AddRequestLobbyListResultCountFilter), "Sets the maximum number of lobbies returned by RequestLobbyList.", new[] { "maxResults: Maximum number of lobby results." }, null)]
+        public void AddRequestLobbyListResultCountFilter(int maxResults)
+        {
+            SteamNativeApi.MatchmakingAddRequestLobbyListResultCountFilter(maxResults);
+        }
+
+        [Documentation(nameof(CreateLobby), "Creates a lobby and returns a Steam API call handle.", new[] { "lobbyType: Numeric ELobbyType value.", "maxMembers: Maximum lobby member count." }, null)]
+        public ulong CreateLobby(int lobbyType, int maxMembers)
+        {
+            return SteamNativeApi.MatchmakingCreateLobby(lobbyType, maxMembers);
+        }
+
+        [Documentation(nameof(JoinLobby), "Joins a lobby by SteamID64 and returns a Steam API call handle.", new[] { "steamIdLobby: Lobby SteamID64." }, null)]
+        public ulong JoinLobby(ulong steamIdLobby)
+        {
+            return SteamNativeApi.MatchmakingJoinLobby(steamIdLobby);
+        }
+
+        [Documentation(nameof(LeaveLobby), "Leaves a lobby by SteamID64.", new[] { "steamIdLobby: Lobby SteamID64." }, null)]
+        public void LeaveLobby(ulong steamIdLobby)
+        {
+            SteamNativeApi.MatchmakingLeaveLobby(steamIdLobby);
+        }
+
+        [Documentation(nameof(GetNumLobbyMembers), "Gets the number of members currently in a lobby.", new[] { "steamIdLobby: Lobby SteamID64." }, null)]
+        public int GetNumLobbyMembers(ulong steamIdLobby)
+        {
+            return SteamNativeApi.MatchmakingGetNumLobbyMembers(steamIdLobby);
+        }
+    }
+
+    [Documentation(nameof(SteamMatchmakingServersManager), "Provides access checks for ISteamMatchmakingServers.", null, null)]
+    public class SteamMatchmakingServersManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamMatchmakingServersAvailable();
+    }
+
+    [Documentation(nameof(SteamMusicManager), "Provides access checks for ISteamMusic.", null, null)]
+    public class SteamMusicManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamMusicAvailable();
+
+        [Documentation(nameof(IsEnabled), "Checks whether Steam Music is enabled.", null, null)]
+        public bool IsEnabled()
+        {
+            return SteamNativeApi.MusicIsEnabled();
+        }
+
+        [Documentation(nameof(IsPlaying), "Checks whether Steam Music is currently playing.", null, null)]
+        public bool IsPlaying()
+        {
+            return SteamNativeApi.MusicIsPlaying();
+        }
+
+        [Documentation(nameof(Play), "Starts Steam Music playback.", null, null)]
+        public void Play()
+        {
+            SteamNativeApi.MusicPlay();
+        }
+
+        [Documentation(nameof(Pause), "Pauses Steam Music playback.", null, null)]
+        public void Pause()
+        {
+            SteamNativeApi.MusicPause();
+        }
+
+        [Documentation(nameof(PlayNext), "Advances to the next music track.", null, null)]
+        public void PlayNext()
+        {
+            SteamNativeApi.MusicPlayNext();
+        }
+
+        [Documentation(nameof(PlayPrevious), "Moves to the previous music track.", null, null)]
+        public void PlayPrevious()
+        {
+            SteamNativeApi.MusicPlayPrevious();
+        }
+
+        [Documentation(nameof(GetVolume), "Gets Steam Music volume (0..1 range).", null, null)]
+        public float GetVolume()
+        {
+            return SteamNativeApi.MusicGetVolume();
+        }
+
+        [Documentation(nameof(SetVolume), "Sets Steam Music volume (0..1 range).", new[] { "volume: New volume value." }, null)]
+        public void SetVolume(float volume)
+        {
+            SteamNativeApi.MusicSetVolume(volume);
+        }
+    }
+
+    [Documentation(nameof(SteamPartiesManager), "Provides access checks for ISteamParties.", null, null)]
+    public class SteamPartiesManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamPartiesAvailable();
+    }
+
+    [Documentation(nameof(SteamRemoteStorageManager), "Provides access checks for ISteamRemoteStorage.", null, null)]
+    public class SteamRemoteStorageManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamRemoteStorageAvailable();
+
+        [Documentation(nameof(FileExists), "Checks whether a file exists in Steam Remote Storage.", new[] { "fileName: Cloud file path/name." }, null)]
+        public bool FileExists(string fileName)
+        {
+            return SteamNativeApi.RemoteStorageFileExists(fileName);
+        }
+
+        [Documentation(nameof(GetFileCount), "Gets the number of files in Steam Remote Storage for the current app/user context.", null, null)]
+        public int GetFileCount()
+        {
+            return SteamNativeApi.RemoteStorageGetFileCount();
+        }
+
+        [Documentation(nameof(IsCloudEnabledForApp), "Checks whether Steam Cloud is enabled for this app.", null, null)]
+        public bool IsCloudEnabledForApp()
+        {
+            return SteamNativeApi.RemoteStorageIsCloudEnabledForApp();
+        }
+
+        [Documentation(nameof(FileWrite), "Writes a byte array to a Steam Cloud file.", new[] { "fileName: Cloud file path/name.", "data: Raw file bytes to write." }, null)]
+        public bool FileWrite(string fileName, byte[] data)
+        {
+            return SteamNativeApi.RemoteStorageFileWrite(fileName, data);
+        }
+
+        [Documentation(nameof(FileRead), "Reads a Steam Cloud file into a byte array.", new[] { "fileName: Cloud file path/name.", "data: Output file bytes when read succeeds." }, null)]
+        public bool FileRead(string fileName, out byte[] data)
+        {
+            return SteamNativeApi.RemoteStorageFileRead(fileName, out data);
+        }
+
+        [Documentation(nameof(FileDelete), "Deletes a Steam Cloud file.", new[] { "fileName: Cloud file path/name." }, null)]
+        public bool FileDelete(string fileName)
+        {
+            return SteamNativeApi.RemoteStorageFileDelete(fileName);
+        }
+
+        [Documentation(nameof(GetFileSize), "Gets file size in bytes for a Steam Cloud file.", new[] { "fileName: Cloud file path/name." }, null)]
+        public int GetFileSize(string fileName)
+        {
+            return SteamNativeApi.RemoteStorageGetFileSize(fileName);
+        }
+    }
+
+    [Documentation(nameof(SteamScreenshotsManager), "Provides access checks for ISteamScreenshots.", null, null)]
+    public class SteamScreenshotsManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamScreenshotsAvailable();
+
+        [Documentation(nameof(AddScreenshotToLibrary), "Adds an existing screenshot to the Steam screenshot library.", new[] { "fileNameJpg: Screenshot image path.", "fileNameThumbnail: Thumbnail path.", "width: Image width.", "height: Image height." }, null)]
+        public uint AddScreenshotToLibrary(string fileNameJpg, string fileNameThumbnail, int width, int height)
+        {
+            return SteamNativeApi.ScreenshotsAddScreenshotToLibrary(fileNameJpg, fileNameThumbnail, width, height);
+        }
+
+        [Documentation(nameof(TriggerScreenshot), "Triggers an in-game screenshot event.", null, null)]
+        public void TriggerScreenshot()
+        {
+            SteamNativeApi.ScreenshotsTriggerScreenshot();
+        }
+
+        [Documentation(nameof(HookScreenshots), "Enables or disables screenshot hooks for custom handling.", new[] { "hook: True to hook screenshots." }, null)]
+        public void HookScreenshots(bool hook)
+        {
+            SteamNativeApi.ScreenshotsHookScreenshots(hook);
+        }
+
+        [Documentation(nameof(IsScreenshotsHooked), "Checks whether screenshot hooks are currently enabled.", null, null)]
+        public bool IsScreenshotsHooked()
+        {
+            return SteamNativeApi.ScreenshotsIsScreenshotsHooked();
+        }
+    }
+
+    [Documentation(nameof(SteamUserStatsManager), "Provides access checks for ISteamUserStats.", null, null)]
+    public class SteamUserStatsManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamUserStatsAvailable();
+
+        [Documentation(nameof(RequestUserStats), "Requests user stats for a target SteamID64 and returns a Steam API call handle.", new[] { "steamIdUser: Target SteamID64." }, null)]
+        public ulong RequestUserStats(ulong steamIdUser)
+        {
+            return SteamNativeApi.UserStatsRequestUserStats(steamIdUser);
+        }
+
+        [Documentation(nameof(RequestGlobalStats), "Requests global stats history and returns a Steam API call handle.", new[] { "historyDays: Number of days of history to request." }, null)]
+        public ulong RequestGlobalStats(int historyDays)
+        {
+            return SteamNativeApi.UserStatsRequestGlobalStats(historyDays);
+        }
+
+        [Documentation(nameof(ResetAllStats), "Resets local user stats, optionally including achievements.", new[] { "achievementsToo: True to also clear achievement state." }, null)]
+        public bool ResetAllStats(bool achievementsToo)
+        {
+            return SteamNativeApi.UserStatsResetAllStats(achievementsToo);
+        }
+
+        [Documentation(nameof(GetStatInt32), "Gets a named integer stat value.", new[] { "name: Stat API name.", "data: Output integer stat value." }, null)]
+        public bool GetStatInt32(string name, out int data)
+        {
+            return SteamNativeApi.UserStatsGetStatInt32(name, out data);
+        }
+
+        [Documentation(nameof(SetStatInt32), "Sets a named integer stat value.", new[] { "name: Stat API name.", "data: Integer stat value to set." }, null)]
+        public bool SetStatInt32(string name, int data)
+        {
+            return SteamNativeApi.UserStatsSetStatInt32(name, data);
+        }
+
+        [Documentation(nameof(StoreStats), "Stores pending stats and achievement changes to Steam.", null, null)]
+        public bool StoreStats()
+        {
+            return SteamNativeApi.StoreStats();
+        }
+    }
+
+    [Documentation(nameof(SteamUtilsManager), "Provides access checks for ISteamUtils.", null, null)]
+    public class SteamUtilsManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamUtilsAvailable();
+
+        [Documentation(nameof(GetAppId), "Gets the current Steam AppId reported by SteamUtils.", null, null)]
+        public uint GetAppId()
+        {
+            return SteamNativeApi.GetAppId();
+        }
+
+        [Documentation(nameof(GetIpCountry), "Gets the two-letter country code inferred by Steam based on the current IP.", null, null)]
+        public string GetIpCountry()
+        {
+            return SteamNativeApi.GetIpCountry();
+        }
+
+        [Documentation(nameof(IsOverlayEnabled), "Checks whether Steam Overlay is currently enabled.", null, null)]
+        public bool IsOverlayEnabled()
+        {
+            return SteamNativeApi.IsOverlayEnabled();
+        }
+    }
+
+    [Documentation(nameof(SteamVideoManager), "Provides access checks for ISteamVideo.", null, null)]
+    public class SteamVideoManager
+    {
+        public bool IsAvailable => SteamNativeApi.IsSteamVideoAvailable();
+
+        [Documentation(nameof(GetVideoUrl), "Requests a video URL for a given Steam video app id.", new[] { "videoAppId: Steam video app id." }, null)]
+        public void GetVideoUrl(uint videoAppId)
+        {
+            SteamNativeApi.VideoGetVideoUrl(videoAppId);
+        }
+
+        [Documentation(nameof(IsBroadcasting), "Checks whether the user is broadcasting and returns current viewer count.", new[] { "numberOfViewers: Viewer count output when broadcasting." }, null)]
+        public bool IsBroadcasting(out int numberOfViewers)
+        {
+            return SteamNativeApi.VideoIsBroadcasting(out numberOfViewers);
+        }
+    }
+}
+

OmegaLeo.HelperLib.Steamworks/SteamManager.cs

@@ -17,6 +17,25 @@ steam.Update();
         private static SteamManager _instance;
         private static uint? _configuredAppId;
         private static ILogger _logger = NullLogger.Instance;
+        private static readonly SteamUgcManager UgcManager = new SteamUgcManager();
+        private static readonly SteamRemotePlayManager RemotePlayManager = new SteamRemotePlayManager();
+        private static readonly SteamControllerManager ControllerManager = new SteamControllerManager();
+        private static readonly SteamFriendsManager FriendsManager = new SteamFriendsManager();
+        private static readonly SteamGameCoordinatorManager GameCoordinatorManager = new SteamGameCoordinatorManager();
+        private static readonly SteamGameServerManager GameServerManager = new SteamGameServerManager();
+        private static readonly SteamGameServerStatsManager GameServerStatsManager = new SteamGameServerStatsManager();
+        private static readonly SteamHtmlSurfaceManager HtmlSurfaceManager = new SteamHtmlSurfaceManager();
+        private static readonly SteamInputManager InputManager = new SteamInputManager();
+        private static readonly SteamInventoryManager InventoryManager = new SteamInventoryManager();
+        private static readonly SteamMatchmakingManager MatchmakingManager = new SteamMatchmakingManager();
+        private static readonly SteamMatchmakingServersManager MatchmakingServersManager = new SteamMatchmakingServersManager();
+        private static readonly SteamMusicManager MusicManager = new SteamMusicManager();
+        private static readonly SteamPartiesManager PartiesManager = new SteamPartiesManager();
+        private static readonly SteamRemoteStorageManager RemoteStorageManager = new SteamRemoteStorageManager();
+        private static readonly SteamScreenshotsManager ScreenshotsManager = new SteamScreenshotsManager();
+        private static readonly SteamUserStatsManager UserStatsManager = new SteamUserStatsManager();
+        private static readonly SteamUtilsManager UtilsManager = new SteamUtilsManager();
+        private static readonly SteamVideoManager VideoManager = new SteamVideoManager();
         [Documentation(nameof(Instance), "Singleton access to the Steam manager.", null, null)]
         public static SteamManager Instance => _instance ??= new SteamManager();
 
@@ -50,6 +69,63 @@ steam.Update();
         [Documentation(nameof(IsSteamworksInitialized), "Indicates whether Steamworks is initialized and ready for API calls.", null, null)]
         public bool IsSteamworksInitialized { get; private set; }
 
+        [Documentation(nameof(Ugc), "Provides access to Steam Workshop (UGC) helper operations.", null, null)]
+        public SteamUgcManager Ugc => UgcManager;
+
+        [Documentation(nameof(RemotePlay), "Provides access to Steam Remote Play helper operations.", null, null)]
+        public SteamRemotePlayManager RemotePlay => RemotePlayManager;
+
+        [Documentation(nameof(Controller), "Provides access to ISteamController bindings.", null, null)]
+        public SteamControllerManager Controller => ControllerManager;
+
+        [Documentation(nameof(Friends), "Provides access to ISteamFriends bindings.", null, null)]
+        public SteamFriendsManager Friends => FriendsManager;
+
+        [Documentation(nameof(GameCoordinator), "Provides access to ISteamGameCoordinator bindings.", null, null)]
+        public SteamGameCoordinatorManager GameCoordinator => GameCoordinatorManager;
+
+        [Documentation(nameof(GameServer), "Provides access to ISteamGameServer bindings.", null, null)]
+        public SteamGameServerManager GameServer => GameServerManager;
+
+        [Documentation(nameof(GameServerStats), "Provides access to ISteamGameServerStats bindings.", null, null)]
+        public SteamGameServerStatsManager GameServerStats => GameServerStatsManager;
+
+        [Documentation(nameof(HtmlSurface), "Provides access to ISteamHTMLSurface bindings.", null, null)]
+        public SteamHtmlSurfaceManager HtmlSurface => HtmlSurfaceManager;
+
+        [Documentation(nameof(Input), "Provides access to ISteamInput bindings.", null, null)]
+        public SteamInputManager Input => InputManager;
+
+        [Documentation(nameof(Inventory), "Provides access to ISteamInventory bindings.", null, null)]
+        public SteamInventoryManager Inventory => InventoryManager;
+
+        [Documentation(nameof(Matchmaking), "Provides access to ISteamMatchmaking bindings.", null, null)]
+        public SteamMatchmakingManager Matchmaking => MatchmakingManager;
+
+        [Documentation(nameof(MatchmakingServers), "Provides access to ISteamMatchmakingServers bindings.", null, null)]
+        public SteamMatchmakingServersManager MatchmakingServers => MatchmakingServersManager;
+
+        [Documentation(nameof(Music), "Provides access to ISteamMusic bindings.", null, null)]
+        public SteamMusicManager Music => MusicManager;
+
+        [Documentation(nameof(Parties), "Provides access to ISteamParties bindings.", null, null)]
+        public SteamPartiesManager Parties => PartiesManager;
+
+        [Documentation(nameof(RemoteStorage), "Provides access to ISteamRemoteStorage bindings.", null, null)]
+        public SteamRemoteStorageManager RemoteStorage => RemoteStorageManager;
+
+        [Documentation(nameof(Screenshots), "Provides access to ISteamScreenshots bindings.", null, null)]
+        public SteamScreenshotsManager Screenshots => ScreenshotsManager;
+
+        [Documentation(nameof(UserStats), "Provides access to ISteamUserStats bindings.", null, null)]
+        public SteamUserStatsManager UserStats => UserStatsManager;
+
+        [Documentation(nameof(Utils), "Provides access to ISteamUtils bindings.", null, null)]
+        public SteamUtilsManager Utils => UtilsManager;
+
+        [Documentation(nameof(Video), "Provides access to ISteamVideo bindings.", null, null)]
+        public SteamVideoManager Video => VideoManager;
+
         private SteamManager()
         {
             try

OmegaLeo.HelperLib.Steamworks/SteamRemotePlayManager.cs

@@ -0,0 +1,49 @@
+using OmegaLeo.HelperLib.Shared.Attributes;
+
+namespace OmegaLeo.HelperLib.Steamworks
+{
+    [Documentation(nameof(SteamRemotePlayManager), "Provides helper methods for Steam Remote Play session inspection.", null,
+        @"```csharp
+var remotePlay = SteamManager.Instance.RemotePlay;
+var sessionCount = remotePlay.GetSessionCount();
+```")]
+    public class SteamRemotePlayManager
+    {
+        [Documentation(nameof(GetSessionCount), "Gets the number of active Remote Play sessions for the current user.", null, null)]
+        public uint GetSessionCount()
+        {
+            return SteamNativeApi.GetRemotePlaySessionCount();
+        }
+
+        [Documentation(nameof(GetSessionId), "Gets a Remote Play session ID by zero-based session index.", new[] { "sessionIndex: Zero-based index into the active sessions list." }, null)]
+        public uint GetSessionId(int sessionIndex)
+        {
+            return SteamNativeApi.GetRemotePlaySessionId(sessionIndex);
+        }
+
+        [Documentation(nameof(GetSessionSteamId), "Gets the SteamID for the remote user in a session.", new[] { "sessionId: Remote Play session ID." }, null)]
+        public ulong GetSessionSteamId(uint sessionId)
+        {
+            return SteamNativeApi.GetRemotePlaySessionSteamId(sessionId);
+        }
+
+        [Documentation(nameof(GetSessionClientName), "Gets the client device name for a remote session.", new[] { "sessionId: Remote Play session ID." }, null)]
+        public string GetSessionClientName(uint sessionId)
+        {
+            return SteamNativeApi.GetRemotePlaySessionClientName(sessionId);
+        }
+
+        [Documentation(nameof(GetSessionClientFormFactor), "Gets the client form-factor value for a session (matches Steam's ESteamDeviceFormFactor numeric values).", new[] { "sessionId: Remote Play session ID." }, null)]
+        public int GetSessionClientFormFactor(uint sessionId)
+        {
+            return SteamNativeApi.GetRemotePlaySessionClientFormFactor(sessionId);
+        }
+
+        [Documentation(nameof(TryGetSessionClientResolution), "Gets the streaming client resolution for a session.", new[] { "sessionId: Remote Play session ID.", "resolutionX: Width output.", "resolutionY: Height output." }, null)]
+        public bool TryGetSessionClientResolution(uint sessionId, out int resolutionX, out int resolutionY)
+        {
+            return SteamNativeApi.TryGetRemotePlaySessionClientResolution(sessionId, out resolutionX, out resolutionY);
+        }
+    }
+}
+

OmegaLeo.HelperLib.Steamworks/SteamUgcItemUpdateOptions.cs

@@ -0,0 +1,30 @@
+using OmegaLeo.HelperLib.Shared.Attributes;
+
+namespace OmegaLeo.HelperLib.Steamworks
+{
+    [Documentation(nameof(SteamUgcItemUpdateOptions), "Declarative update payload for workshop item editing convenience APIs.", null, null)]
+    public class SteamUgcItemUpdateOptions
+    {
+        [Documentation(nameof(Title), "Workshop item title.", null, null)]
+        public string Title { get; set; }
+
+        [Documentation(nameof(Description), "Workshop item description.", null, null)]
+        public string Description { get; set; }
+
+        [Documentation(nameof(Metadata), "Workshop item metadata string.", null, null)]
+        public string Metadata { get; set; }
+
+        [Documentation(nameof(Visibility), "Numeric ERemoteStoragePublishedFileVisibility value.", null, null)]
+        public uint? Visibility { get; set; }
+
+        [Documentation(nameof(Tags), "Workshop tag list.", null, null)]
+        public string[] Tags { get; set; }
+
+        [Documentation(nameof(ContentFolder), "Absolute path to workshop content folder.", null, null)]
+        public string ContentFolder { get; set; }
+
+        [Documentation(nameof(PreviewFile), "Absolute path to workshop preview image.", null, null)]
+        public string PreviewFile { get; set; }
+    }
+}
+

OmegaLeo.HelperLib.Steamworks/SteamUgcItemUpdateSession.cs

@@ -0,0 +1,73 @@
+using OmegaLeo.HelperLib.Shared.Attributes;
+
+namespace OmegaLeo.HelperLib.Steamworks
+{
+    [Documentation(nameof(SteamUgcItemUpdateSession), "Fluent helper for editing and submitting a workshop item update.", null, null)]
+    public class SteamUgcItemUpdateSession
+    {
+        private readonly SteamUgcManager _ugcManager;
+        private readonly uint _consumerAppId;
+        private readonly ulong _publishedFileId;
+        private readonly SteamUgcItemUpdateOptions _options = new SteamUgcItemUpdateOptions();
+
+        internal SteamUgcItemUpdateSession(SteamUgcManager ugcManager, uint consumerAppId, ulong publishedFileId)
+        {
+            _ugcManager = ugcManager;
+            _consumerAppId = consumerAppId;
+            _publishedFileId = publishedFileId;
+        }
+
+        public SteamUgcItemUpdateSession WithTitle(string title)
+        {
+            _options.Title = title;
+            return this;
+        }
+
+        public SteamUgcItemUpdateSession WithDescription(string description)
+        {
+            _options.Description = description;
+            return this;
+        }
+
+        public SteamUgcItemUpdateSession WithMetadata(string metadata)
+        {
+            _options.Metadata = metadata;
+            return this;
+        }
+
+        public SteamUgcItemUpdateSession WithVisibility(uint visibility)
+        {
+            _options.Visibility = visibility;
+            return this;
+        }
+
+        public SteamUgcItemUpdateSession WithTags(params string[] tags)
+        {
+            _options.Tags = tags;
+            return this;
+        }
+
+        public SteamUgcItemUpdateSession WithContentFolder(string contentFolder)
+        {
+            _options.ContentFolder = contentFolder;
+            return this;
+        }
+
+        public SteamUgcItemUpdateSession WithPreviewFile(string previewFile)
+        {
+            _options.PreviewFile = previewFile;
+            return this;
+        }
+
+        [Documentation(nameof(Submit), "Submits the fluent update session and returns a Steam API call handle.", new[]
+        {
+            "changeNote: Changelog note for this update.",
+            "failedStep: Name of the failed step if submission returns 0."
+        }, null)]
+        public ulong Submit(string changeNote, out string failedStep)
+        {
+            return _ugcManager.UpdateItem(_consumerAppId, _publishedFileId, _options, changeNote, out failedStep);
+        }
+    }
+}
+

OmegaLeo.HelperLib.Steamworks/SteamUgcManager.cs

@@ -0,0 +1,240 @@
+using OmegaLeo.HelperLib.Shared.Attributes;
+
+namespace OmegaLeo.HelperLib.Steamworks
+{
+    [Documentation(nameof(SteamUgcManager), "Provides helper methods for common Steam Workshop (UGC) operations such as queries and subscriptions.", null,
+        @"```csharp
+var ugc = new SteamUgcManager();
+var items = ugc.GetSubscribedItems();
+```")]
+    public class SteamUgcManager
+    {
+        [Documentation(nameof(BeginUpdateSession), "Begins a fluent UGC update session for an existing workshop item.", new[]
+        {
+            "consumerAppId: Your game AppId.",
+            "publishedFileId: Existing workshop item ID."
+        }, null)]
+        public SteamUgcItemUpdateSession BeginUpdateSession(uint consumerAppId, ulong publishedFileId)
+        {
+            return new SteamUgcItemUpdateSession(this, consumerAppId, publishedFileId);
+        }
+
+        [Documentation(nameof(ApplyItemUpdate), "Applies all non-null/non-empty fields from a UGC update options object to an existing update handle.", new[]
+        {
+            "updateHandle: Handle from StartItemUpdate.",
+            "options: Options object containing fields to apply.",
+            "failedStep: Name of the field that failed to apply, if any."
+        }, null)]
+        public bool ApplyItemUpdate(ulong updateHandle, SteamUgcItemUpdateOptions options, out string failedStep)
+        {
+            failedStep = string.Empty;
+
+            if (updateHandle == 0 || options == null)
+            {
+                failedStep = "InvalidArguments";
+                return false;
+            }
+
+            if (!string.IsNullOrWhiteSpace(options.Title) && !SetItemTitle(updateHandle, options.Title))
+            {
+                failedStep = nameof(options.Title);
+                return false;
+            }
+
+            if (!string.IsNullOrWhiteSpace(options.Description) && !SetItemDescription(updateHandle, options.Description))
+            {
+                failedStep = nameof(options.Description);
+                return false;
+            }
+
+            if (!string.IsNullOrWhiteSpace(options.Metadata) && !SetItemMetadata(updateHandle, options.Metadata))
+            {
+                failedStep = nameof(options.Metadata);
+                return false;
+            }
+
+            if (options.Visibility.HasValue && !SetItemVisibility(updateHandle, options.Visibility.Value))
+            {
+                failedStep = nameof(options.Visibility);
+                return false;
+            }
+
+            if (options.Tags != null && options.Tags.Length > 0 && !SetItemTags(updateHandle, options.Tags))
+            {
+                failedStep = nameof(options.Tags);
+                return false;
+            }
+
+            if (!string.IsNullOrWhiteSpace(options.ContentFolder) && !SetItemContent(updateHandle, options.ContentFolder))
+            {
+                failedStep = nameof(options.ContentFolder);
+                return false;
+            }
+
+            if (!string.IsNullOrWhiteSpace(options.PreviewFile) && !SetItemPreview(updateHandle, options.PreviewFile))
+            {
+                failedStep = nameof(options.PreviewFile);
+                return false;
+            }
+
+            return true;
+        }
+
+        [Documentation(nameof(UpdateItem), "Convenience method that starts an item update, applies option fields, and submits the update in one call.", new[]
+        {
+            "consumerAppId: Your game AppId.",
+            "publishedFileId: Existing workshop item ID.",
+            "options: Options object containing fields to update.",
+            "changeNote: Changelog note for submission.",
+            "failedStep: Name of the failed step when the call returns 0."
+        }, null)]
+        public ulong UpdateItem(uint consumerAppId, ulong publishedFileId, SteamUgcItemUpdateOptions options, string changeNote, out string failedStep)
+        {
+            failedStep = string.Empty;
+
+            var updateHandle = StartItemUpdate(consumerAppId, publishedFileId);
+            if (updateHandle == 0)
+            {
+                failedStep = nameof(StartItemUpdate);
+                return 0;
+            }
+
+            if (!ApplyItemUpdate(updateHandle, options, out failedStep))
+            {
+                return 0;
+            }
+
+            var submitHandle = SubmitItemUpdate(updateHandle, changeNote);
+            if (submitHandle == 0)
+            {
+                failedStep = nameof(SubmitItemUpdate);
+            }
+
+            return submitHandle;
+        }
+
+        [Documentation(nameof(CreateItem), "Creates a new Workshop item and returns a Steam API call handle.", new[]
+        {
+            "consumerAppId: Your game AppId.",
+            "fileType: Numeric EWorkshopFileType value."
+        }, null)]
+        public ulong CreateItem(uint consumerAppId, uint fileType)
+        {
+            return SteamNativeApi.CreateItem(consumerAppId, fileType);
+        }
+
+        [Documentation(nameof(StartItemUpdate), "Starts an update transaction for an existing Workshop item.", new[]
+        {
+            "consumerAppId: Your game AppId.",
+            "publishedFileId: Existing workshop item ID."
+        }, null)]
+        public ulong StartItemUpdate(uint consumerAppId, ulong publishedFileId)
+        {
+            return SteamNativeApi.StartItemUpdate(consumerAppId, publishedFileId);
+        }
+
+        [Documentation(nameof(SetItemTitle), "Sets workshop item title for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "title: New item title." }, null)]
+        public bool SetItemTitle(ulong updateHandle, string title)
+        {
+            return SteamNativeApi.SetItemTitle(updateHandle, title);
+        }
+
+        [Documentation(nameof(SetItemDescription), "Sets workshop item description for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "description: New item description." }, null)]
+        public bool SetItemDescription(ulong updateHandle, string description)
+        {
+            return SteamNativeApi.SetItemDescription(updateHandle, description);
+        }
+
+        [Documentation(nameof(SetItemMetadata), "Sets workshop item metadata for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "metadata: Metadata string (up to Steam's size limits)." }, null)]
+        public bool SetItemMetadata(ulong updateHandle, string metadata)
+        {
+            return SteamNativeApi.SetItemMetadata(updateHandle, metadata);
+        }
+
+        [Documentation(nameof(SetItemVisibility), "Sets workshop item visibility for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "visibility: Numeric ERemoteStoragePublishedFileVisibility value." }, null)]
+        public bool SetItemVisibility(ulong updateHandle, uint visibility)
+        {
+            return SteamNativeApi.SetItemVisibility(updateHandle, visibility);
+        }
+
+        [Documentation(nameof(SetItemTags), "Sets workshop item tags for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "tags: Array of tag strings." }, null)]
+        public bool SetItemTags(ulong updateHandle, string[] tags)
+        {
+            return SteamNativeApi.SetItemTags(updateHandle, tags);
+        }
+
+        [Documentation(nameof(SetItemContent), "Sets workshop item content folder path for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "contentFolder: Absolute path to content folder." }, null)]
+        public bool SetItemContent(ulong updateHandle, string contentFolder)
+        {
+            return SteamNativeApi.SetItemContent(updateHandle, contentFolder);
+        }
+
+        [Documentation(nameof(SetItemPreview), "Sets workshop item preview image path for a pending update.", new[] { "updateHandle: Handle from StartItemUpdate.", "previewFile: Absolute path to preview image file." }, null)]
+        public bool SetItemPreview(ulong updateHandle, string previewFile)
+        {
+            return SteamNativeApi.SetItemPreview(updateHandle, previewFile);
+        }
+
+        [Documentation(nameof(SubmitItemUpdate), "Submits a pending workshop item update and returns a Steam API call handle.", new[] { "updateHandle: Handle from StartItemUpdate.", "changeNote: Changelog note for the update." }, null)]
+        public ulong SubmitItemUpdate(ulong updateHandle, string changeNote)
+        {
+            return SteamNativeApi.SubmitItemUpdate(updateHandle, changeNote);
+        }
+
+        [Documentation(nameof(GetItemUpdateProgress), "Gets progress state for a pending item update upload.", new[] { "updateHandle: Handle from StartItemUpdate.", "bytesProcessed: Uploaded bytes output.", "bytesTotal: Total bytes output." }, null)]
+        public uint GetItemUpdateProgress(ulong updateHandle, out ulong bytesProcessed, out ulong bytesTotal)
+        {
+            return SteamNativeApi.GetItemUpdateProgress(updateHandle, out bytesProcessed, out bytesTotal);
+        }
+
+        [Documentation(nameof(CreateQueryAllUgcRequest), "Creates a UGC query request handle for workshop discovery.", new[]
+        {
+            "queryType: Numeric EUGCQuery value from Steamworks docs.",
+            "matchingType: Numeric EUGCMatchingUGCType value from Steamworks docs.",
+            "creatorAppId: AppId filter for creator app.",
+            "consumerAppId: AppId filter for consumer app.",
+            "page: Query page number, starting at 1."
+        }, null)]
+        public ulong CreateQueryAllUgcRequest(uint queryType, uint matchingType, uint creatorAppId, uint consumerAppId, uint page = 1)
+        {
+            return SteamNativeApi.CreateQueryAllUgcRequest(queryType, matchingType, creatorAppId, consumerAppId, page);
+        }
+
+        [Documentation(nameof(SendQueryUgcRequest), "Submits an existing UGC query request and returns a Steam API call handle.", new[] { "queryHandle: UGC query handle returned from CreateQueryAllUgcRequest." }, null)]
+        public ulong SendQueryUgcRequest(ulong queryHandle)
+        {
+            return SteamNativeApi.SendQueryUgcRequest(queryHandle);
+        }
+
+        [Documentation(nameof(ReleaseQueryUgcRequest), "Releases a UGC query handle after you are done with query results.", new[] { "queryHandle: UGC query handle to release." }, null)]
+        public bool ReleaseQueryUgcRequest(ulong queryHandle)
+        {
+            return SteamNativeApi.ReleaseQueryUgcRequest(queryHandle);
+        }
+
+        [Documentation(nameof(GetNumSubscribedItems), "Gets the number of workshop items the current user is subscribed to.", null, null)]
+        public uint GetNumSubscribedItems()
+        {
+            return SteamNativeApi.GetNumSubscribedItems();
+        }
+
+        [Documentation(nameof(GetSubscribedItems), "Gets subscribed workshop item IDs for the current user.", new[] { "maxEntries: Maximum number of subscribed IDs to retrieve." }, null)]
+        public ulong[] GetSubscribedItems(uint maxEntries = 1024)
+        {
+            return SteamNativeApi.GetSubscribedItems(maxEntries);
+        }
+
+        [Documentation(nameof(SubscribeItem), "Subscribes the current user to a workshop item.", new[] { "publishedFileId: Published file ID of the workshop item." }, null)]
+        public ulong SubscribeItem(ulong publishedFileId)
+        {
+            return SteamNativeApi.SubscribeItem(publishedFileId);
+        }
+
+        [Documentation(nameof(UnsubscribeItem), "Unsubscribes the current user from a workshop item.", new[] { "publishedFileId: Published file ID of the workshop item." }, null)]
+        public ulong UnsubscribeItem(ulong publishedFileId)
+        {
+            return SteamNativeApi.UnsubscribeItem(publishedFileId);
+        }
+    }
+}
+

OmegaLeo.HelperLib.Web/Views/Home/Library.cshtml

@@ -81,9 +81,44 @@
                                             <tbody>
                                                 @foreach (var desc in classDoc.Descriptions)
                                                 {
+                                                    var methodParameters = desc.MethodParameters ?? Array.Empty<string>();
+                                                    var attributeParameters = desc.Parameters ?? Array.Empty<string>();
+                                                    var methodParameterSet = new HashSet<string>(methodParameters, StringComparer.OrdinalIgnoreCase);
+                                                    var filteredAttributeParameters = attributeParameters
+                                                        .Where(p => !methodParameterSet.Contains(p))
+                                                        .Distinct(StringComparer.OrdinalIgnoreCase)
+                                                        .ToArray();
+
                                                     <tr>
                                                         <td><code>@desc.Title</code></td>
                                                         <td>@Html.Raw(Markdig.Markdown.ToHtml(desc.Description))<br/>
+                                                            @if (desc.ReturnType.IsNotNullOrEmpty())
+                                                            {
+                                                                <strong>Returns:</strong> <code>@desc.ReturnType</code><br/>
+                                                            }
+
+                                                            @if (methodParameters.Any())
+                                                            {
+                                                                <strong>Parameters:</strong>
+                                                                <ul class="mb-2">
+                                                                    @foreach (var methodParameter in methodParameters)
+                                                                    {
+                                                                        <li><code>@methodParameter</code></li>
+                                                                    }
+                                                                </ul>
+                                                            }
+
+                                                            @if (filteredAttributeParameters.Any())
+                                                            {
+                                                                <strong>Attribute Args:</strong>
+                                                                <ul class="mb-2">
+                                                                    @foreach (var attributeParameter in filteredAttributeParameters)
+                                                                    {
+                                                                        <li><code>@attributeParameter</code></li>
+                                                                    }
+                                                                </ul>
+                                                            }
+
                                                             @if (desc.CodeExample.IsNotNullOrEmpty())
                                                             {
                                                                 <strong>Example:</strong><br/>

OmegaLeo.HelperLib.Web/Views/Shared/_Layout.cshtml

@@ -39,6 +39,9 @@
                         <li class="nav-item">
                             <a class="nav-link" asp-area="" asp-controller="Home" asp-action="Library" asp-route-id="shared">Shared Components</a>
                         </li>
+                        <li class="nav-item">
+                            <a class="nav-link" asp-area="" asp-controller="Home" asp-action="Library" asp-route-id="steamworks">Steamworks</a>
+                        </li>
                     </ul>
                     
                     <ul class="navbar-nav ms-auto">