Namespace Unity.Steamworks.Interop

Classes

CallbackIdentityAttribute

Tags a generated callback struct with its Steam callback id (its k_iCallback), which Subscribe<T>(Action<T>, bool) uses to route the subscription.

Constants

The Steamworks SDK's constants and interface-version strings.

Game-server Steam API lifecycle, the server-pipe counterpart of SteamAPI. Subscribe with gameServer: true on SteamCallbacks to receive its callbacks. Its SteamDispatchMode is set separately from the client pipe's.

ISteamMatchmakingPingResponse

Managed implementation of the C++ ISteamMatchmakingPingResponse callback sink passed to PingServer(uint, ushort, ISteamMatchmakingPingResponse). Dispose it once the query resolves (a ISteamMatchmakingPingResponse.ServerRespondedHandler or ISteamMatchmakingPingResponse.ServerFailedToRespondHandler call) or is cancelled with CancelServerQuery(HServerQuery), and not before. An undisposed sink is never collected.

Handlers are invoked on the thread that dispatches the pipe: the package's callback thread, or the thread that calls RunFrameCallbacks(bool) or performs its own dispatch. When that is not the main thread, calls to Unity APIs must be marshalled to the main thread. Handler exceptions are caught and routed to ExceptionHandler.

ISteamMatchmakingServerListResponse

Managed implementation of the C++ ISteamMatchmakingServerListResponse callback sink passed to the SteamMatchmakingServers server-list requests. Steam calls it while the request is active, including again after RefreshQuery(HServerListRequest). Dispose it once ISteamMatchmakingServerListResponse.RefreshCompleteHandler has fired, or after CancelQuery(HServerListRequest) or ReleaseRequest(HServerListRequest), and not before. An undisposed sink is never collected.

Handlers are invoked on the thread that dispatches the pipe: the package's callback thread, or the thread that calls RunFrameCallbacks(bool) or performs its own dispatch. Unlike Subscribe<T>(Action<T>, bool) handlers, they are not forwarded to the main thread, so calls to Unity APIs must be marshalled to it. Handler exceptions are caught and routed to ExceptionHandler.

InteropHelpers

Marshalling helpers for the generated wrappers: UTF-8 strings, fixed-size char buffers, SteamParamStringArray_t, and the API-initialization guards.

InteropHelpers.SteamParamStringArray

Marshals a string list into a native SteamParamStringArray_t for one call. Because it is a SafeHandle parameter, the marshaller keeps it alive for the whole native call. The generated wrappers construct it inline, so as a plain IntPtr it could be collected while Steam reads it.

InteropHelpers.UTF8StringHandle

A null-terminated UTF-8 copy of a string, passed directly to a [DllImport] and freed on Dispose.

MMKVPMarshaller

Marshals a MatchMakingKeyValuePair_t[] into the MatchMakingKeyValuePair_t ** the SteamMatchmakingServers server-list requests take: a native array of pointers, each to a native copy of one filter.

SteamAPI

Client-side Steam API lifecycle. InitEx(out string, SteamDispatchMode) initializes the API and starts callback dispatch; call it on the main thread so callbacks are delivered there. Shutdown() undoes it.

SteamApps

Purpose: interface to app data

SteamCallResultException

Thrown when a Steam async call fails to start, is already being awaited, or completes without a usable result, including an IO failure.

SteamCallbacks

Steam callbacks and call results: subscribe by generated struct type, await call results as tasks, or receive every message in raw form through a single event. Handlers run on the main thread, or inline on the polling thread when there is no main-thread SynchronizationContext (e.g. headless). On a pipe initialized with External, subscribing and awaiting throw.

SteamClient

Purpose: Interface to creating a new steam instance, or to connect to an existing steam instance, whether it's in a different process or is local. For most scenarios this is all handled automatically via SteamAPI_Init(). You'll only need these APIs if you have a more complex versioning scheme, or if you want to implement a multiplexed gameserver where a single process is handling multiple games at once with independent gameserver SteamIDs.

SteamConfig

Per-platform native library names and the interop struct pack size.

SteamFriends

Purpose: interface to accessing information about individual users, that can be a friend, in a group, on a game server or in a lobby with the local user

SteamGameServer

Purpose: Functions for authenticating users via Steam to play on a game server

SteamGameServerClient

SteamGameServerHTTP

Purpose: interface to http client

SteamGameServerInventory

Purpose: Steam Inventory query and manipulation API

SteamGameServerNetworking

Purpose: Functions for making connections and sending data between clients, traversing NAT's where possible NOTE: This interface is deprecated and may be removed in a future release of the Steamworks SDK. Please see ISteamNetworkingSockets and ISteamNetworkingMessages

SteamGameServerNetworkingMessages

The non-connection-oriented interface to send and receive messages (whether they be "clients" or "servers"). ISteamNetworkingSockets is connection-oriented (like TCP), meaning you need to listen and connect, and then you send messages using a connection handle. ISteamNetworkingMessages is more like UDP, in that you can just send messages to arbitrary peers at any time. The underlying connections are established implicitly. Under the hood ISteamNetworkingMessages works on top of the ISteamNetworkingSockets code, so you get the same routing and messaging efficiency. The difference is mainly in your responsibility to explicitly establish a connection and the type of feedback you get about the state of the connection. Both interfaces can do "P2P" communications, and both support both unreliable and reliable messages, fragmentation and reassembly. The primary purpose of this interface is to be "like UDP", so that UDP-based code can be ported easily to take advantage of relayed connections. If you find yourself needing more low level information or control, or to be able to better handle failure, then you probably need to use ISteamNetworkingSockets directly. Also, note that if your main goal is to obtain a connection between two peers without concerning yourself with assigning roles of "client" and "server", you may find the symmetric connection mode of ISteamNetworkingSockets useful. (See k_ESteamNetworkingConfig_SymmetricConnect.)

SteamGameServerNetworkingSockets

Lower level networking API.

Connection-oriented API (like TCP, not UDP). When sending and receiving messages, a connection handle is used. (For a UDP-style interface, where the peer is identified by their address with each send/recv call, see ISteamNetworkingMessages.) The typical pattern is for a "server" to "listen" on a "listen socket." A "client" will "connect" to the server, and the server will "accept" the connection. If you have a symmetric situation where either peer may initiate the connection and server/client roles are not clearly defined, check out k_ESteamNetworkingConfig_SymmetricConnect.
But unlike TCP, it's message-oriented, not stream-oriented.
Mix of reliable and unreliable messages
Fragmentation and reassembly
Supports connectivity over plain UDP
Also supports SDR ("Steam Datagram Relay") connections, which are addressed by the identity of the peer. There is a "P2P" use case and a "hosted dedicated server" use case. Note that neither of the terms "connection" nor "socket" necessarily correspond one-to-one with an underlying UDP socket. An attempt has been made to keep the semantics as similar to the standard socket model when appropriate, but some deviations do exist. See also: ISteamNetworkingMessages, the UDP-style interface. This API might be easier to use, especially when porting existing UDP code.

SteamGameServerNetworkingUtils

Misc networking utilities for checking the local networking environment and estimating pings.

SteamGameServerStats

Purpose: Functions for authenticating users via Steam to play on a game server

SteamGameServerUGC

Purpose: Steam UGC support API

SteamGameServerUtils

Purpose: interface to user independent utility functions

SteamHTMLSurface

Purpose: Functions for displaying HTML pages and interacting with them

SteamHTTP

Purpose: interface to http client

SteamInput

Purpose: Steam Input API

SteamInventory

Purpose: Steam Inventory query and manipulation API

SteamMatchmaking

Purpose: Functions for match making services for clients to get to favorites and to operate on game lobbies.

SteamMatchmakingServers

Purpose: Functions for match making services for clients to get to game lists and details

SteamMusic

Purpose: Functions to control music playback in the steam client

SteamNetworking

SteamNetworkingMessages

SteamNetworkingSockets

Lower level networking API.

Connection-oriented API (like TCP, not UDP). When sending and receiving messages, a connection handle is used. (For a UDP-style interface, where the peer is identified by their address with each send/recv call, see ISteamNetworkingMessages.) The typical pattern is for a "server" to "listen" on a "listen socket." A "client" will "connect" to the server, and the server will "accept" the connection. If you have a symmetric situation where either peer may initiate the connection and server/client roles are not clearly defined, check out k_ESteamNetworkingConfig_SymmetricConnect.
But unlike TCP, it's message-oriented, not stream-oriented.
Mix of reliable and unreliable messages
Fragmentation and reassembly
Supports connectivity over plain UDP
Also supports SDR ("Steam Datagram Relay") connections, which are addressed by the identity of the peer. There is a "P2P" use case and a "hosted dedicated server" use case. Note that neither of the terms "connection" nor "socket" necessarily correspond one-to-one with an underlying UDP socket. An attempt has been made to keep the semantics as similar to the standard socket model when appropriate, but some deviations do exist. See also: ISteamNetworkingMessages, the UDP-style interface. This API might be easier to use, especially when porting existing UDP code.

SteamNetworkingUtils

Misc networking utilities for checking the local networking environment and estimating pings.

SteamParentalSettings

Wrappers for the Steamworks ISteamParentalSettings interface.

SteamParties

Wrappers for the Steamworks ISteamParties interface.

SteamRemotePlay

COMPILE_TIME_ASSERT( sizeof( RemotePlayInput_t ) == 64 ); Purpose: Functions to provide information about Steam Remote Play sessions

SteamRemoteStorage

Purpose: Functions for accessing, reading and writing files stored remotely and cached locally

SteamScreenshots

Purpose: Functions for adding screenshots to the user's screenshot library

SteamStructLayout

Checks that StructPackSize, chosen from compile-time platform symbols, matches the pack Valve's binaries use on the running OS (8 on Windows, 4 elsewhere). A mismatch misreads every callback payload without crashing, so InitEx(out string, SteamDispatchMode) refuses to initialize instead.

SteamTimeline

Purpose: Steam Timeline API

SteamUGC

Purpose: Steam UGC support API

SteamUser

Purpose: Functions for accessing and manipulating a steam account associated with one client instance

SteamUserStats

Purpose: Functions for accessing stats, achievements, and leaderboard information

SteamUtils

Purpose: interface to user independent utility functions

SteamVideo

callbacks Purpose: Steam Video API

gameserveritem_t

Data describing a single game server, per matchmakingtypes.h. Marshalled out of native memory by ISteamMatchmakingServers.GetServerDetails, so the layout must match the C++ class exactly: with the header's natural alignment the strings are inline UTF-8 char buffers and the total size is 380 bytes. A reference type so a server entry can be absent (null), matching the pointer the native API returns.

Structs

AccountID_t

Wraps the Steamworks AccountID_t handle, a uint.

ActiveBeaconsUpdated_t

The list of active beacons may have changed

AddAppDependencyResult_t

Purpose: The result of a call to AddAppDependency

AddUGCDependencyResult_t

Purpose: The result of a call to AddDependency

AppId_t

Wraps the Steamworks AppId_t handle, a uint.

AppProofOfPurchaseKeyResponse_t

Purpose: response to RequestAppProofOfPurchaseKey/RequestAllProofOfPurchaseKeys for supporting third-party CD keys, or other proof-of-purchase systems.

AppResumingFromSuspend_t

k_iSteamUtilsCallbacks + 15 through 35 are taken

AssociateWithClanResult_t

Sent as a reply to AssociateWithClan()

AvailableBeaconLocationsUpdated_t

The list of possible Party beacon locations has changed

AvatarImageLoaded_t

Purpose: called when an avatar is loaded in from a previous GetLargeFriendAvatar() call if the image wasn't already available

BroadcastUploadStart_t

Payload of the Steamworks BroadcastUploadStart_t callback.

BroadcastUploadStop_t

Payload of the Steamworks BroadcastUploadStop_t callback.

CGameID

An app id, type and mod id packed into 64 bits, per steamclientpublic.h: bits 0-23 app id, 24-31 type, 32-63 mod id. Holds the packed value instead of C++'s bitfield union, so it stays 8 bytes and blittable.

CSteamID

A 64-bit Steam id, per steamclientpublic.h: bits 0-31 account id, 32-51 account instance, 52-55 account type, 56-63 universe. Holds the packed value instead of C++'s bitfield union, so it stays 8 bytes and blittable and appears directly in P/Invoke signatures.

CallbackMsg_t

structure that contains client callback data see callbacks documentation for more details Internal structure used in manual callback dispatch

ChangeNumOpenSlotsCallback_t

Response to ChangeNumOpenSlots call

CheckFileSignature_t

callback for CheckFileSignature

ClanOfficerListResponse_t

Purpose: marks the return of a request officer list call

ClientGameServerDeny_t

Purpose: Sent by the Steam server to the client telling it to disconnect from the specified game server, which it may be in the process of or already connected to. The game client should immediately disconnect upon receiving this message. This can usually occur if the user doesn't have rights to play on the game server.

ComputeNewPlayerCompatibilityResult_t

Sent as a reply to ComputeNewPlayerCompatibility()

CreateBeaconCallback_t

Response to CreateBeacon request. If successful, the beacon ID is provided.

CreateItemResult_t

Purpose: result for ISteamUGC::CreateItem()

DeleteItemResult_t

Purpose: The result of a call to DeleteItem

DepotId_t

Wraps the Steamworks DepotId_t handle, a uint.

DlcInstalled_t

callbacks Purpose: posted after the user gains ownership of DLC & that DLC is installed

DownloadClanActivityCountsResult_t

Purpose: a DownloadClanActivityCounts() call has finished

DownloadItemResult_t

Purpose: result of DownloadItem(), existing item files can be accessed again

DurationControl_t

Purpose: sent for games with enabled anti indulgence / duration control, for enabled users. Lets the game know whether the user can keep playing or whether the game should exit, and returns info about remaining gameplay time. This callback is fired asynchronously in response to timers triggering. It is also fired in response to calls to GetDurationControl().

EncryptedAppTicketResponse_t

Purpose: Result from RequestEncryptedAppTicket

EquippedProfileItemsChanged_t

Purpose: A user's equipped profile items have changed

EquippedProfileItems_t

Purpose:

FavoritesListAccountsUpdated_t

used by now obsolete RequestFriendsLobbiesResponse_t enum { k_iCallback = k_iSteamMatchmakingCallbacks + 14 }; used by now obsolete PSNGameBootInviteResult_t enum { k_iCallback = k_iSteamMatchmakingCallbacks + 15 }; Purpose: Result of our request to create a Lobby m_eResult == k_EResultOK on success at this point, the lobby has been joined and is ready for use a LobbyEnter_t callback will also be received (since the local user is joining their own lobby)

FavoritesListChanged_t

Callbacks for ISteamMatchmaking (which go through the regular Steam callback registration system) Purpose: a server was added/removed from the favorites list, you should refresh now

FileDetailsResult_t

Purpose: response to GetFileDetails

FilterTextDictionaryChanged_t

The text filtering dictionary has changed

FloatingGamepadTextInputDismissed_t

k_iSteamUtilsCallbacks + 37 is taken The floating on-screen keyboard has been closed

FriendGameInfo_t

friend game played information

FriendRichPresenceUpdate_t

Purpose: callback indicating updated data about friends rich presence information

FriendsEnumerateFollowingList_t

Payload of the Steamworks FriendsEnumerateFollowingList_t callback.

FriendsGetFollowerCount_t

Payload of the Steamworks FriendsGetFollowerCount_t callback.

FriendsGroupID_t

Wraps the Steamworks FriendsGroupID_t handle, a short.

FriendsIsFollowing_t

Payload of the Steamworks FriendsIsFollowing_t callback.

GCMessageAvailable_t

callbacks callback notification - A new message is available for reading from the message queue

GCMessageFailed_t

callback notification - A message failed to make it to the GC. It may be down temporarily

GSClientAchievementStatus_t

NOTE: callback values 4 and 5 are skipped because they are used for old deprecated callbacks, do not reuse them here. client achievement info

GSClientApprove_t

callbacks client has been approved to connect to this game server

GSClientDeny_t

client has been denied to connection to this game server

GSClientGroupStatus_t

send as a reply to RequestUserGroupStatus()

GSClientKick_t

request the game server should kick the user

GSGameplayStats_t

GS gameplay stats info

GSPolicyResponse_t

received when the game server requests to be displayed as secure (VAC protected) m_bSecure is true if the game server should display itself as secure to users, false otherwise

GSReputation_t

Sent as a reply to GetServerReputation()

GSStatsReceived_t

callbacks Purpose: called when the latests stats and achievements have been received from the server

GSStatsStored_t

Purpose: result of a request to store the user stats for a game

GSStatsUnloaded_t

Purpose: Callback indicating that a user's stats have been unloaded. Call RequestUserStats again to access stats for this user

GameConnectedChatJoin_t

Purpose: a user has joined a clan chat

GameConnectedChatLeave_t

Purpose: a user has left the chat we're in

GameConnectedClanChatMsg_t

Purpose: a chat message has been received for a clan chat the game has joined

GameConnectedFriendChatMsg_t

Purpose: a chat message has been received from a user

GameLobbyJoinRequested_t

Purpose: called when the user tries to join a lobby from their friends list game client should attempt to connect to specified lobby when this is received

GameOverlayActivated_t

Purpose: posted when game overlay activates or deactivates the game can use this to be pause or resume single player games

GameRichPresenceJoinRequested_t

Purpose: called when the user tries to join a game from their friends list rich presence will have been set with the "connect" key which is set here

GameServerChangeRequested_t

Purpose: called when the user tries to join a different game server from their friends list game client should attempt to connect to specified server when this is received

GameWebCallback_t

Purpose: sent to your game in response to a steam://gamewebcallback/ command

GamepadTextInputDismissed_t

k_iSteamUtilsCallbacks + 13 is taken Full Screen gamepad text input has been closed

GetAppDependenciesResult_t

Purpose: The result of a call to GetAppDependencies. Callback may be called multiple times until all app dependencies have been returned.

GetAuthSessionTicketResponse_t

callback for GetAuthSessionTicket

GetOPFSettingsResult_t

Payload of the Steamworks GetOPFSettingsResult_t callback.

GetTicketForWebApiResponse_t

callback for GetTicketForWebApi

GetUserItemVoteResult_t

Purpose: The result of a call to GetUserItemVote()

GetVideoURLResult_t

Payload of the Steamworks GetVideoURLResult_t callback.

GlobalAchievementPercentagesReady_t

Purpose: Callback indicating that global achievement percentages are fetched

GlobalStatsReceived_t

Purpose: callback indicating global stats have been received. Returned as a result of RequestGlobalStats()

HAuthTicket

Wraps the Steamworks HAuthTicket handle, a uint.

HHTMLBrowser

Wraps the Steamworks HHTMLBrowser handle, a uint.

HServerListRequest

Wraps the Steamworks HServerListRequest handle, a IntPtr.

HServerQuery

Wraps the Steamworks HServerQuery handle, a int.

HSteamListenSocket

Wraps the Steamworks HSteamListenSocket handle, a uint.

HSteamNetConnection

Wraps the Steamworks HSteamNetConnection handle, a uint.

HSteamNetPollGroup

Wraps the Steamworks HSteamNetPollGroup handle, a uint.

HSteamPipe

Wraps the Steamworks HSteamPipe handle, a int.

HSteamUser

Wraps the Steamworks HSteamUser handle, a int.

HTML_BrowserReady_t

callbacks Purpose: The browser is ready for use

HTML_BrowserRestarted_t

Purpose: The browser has restarted due to an internal failure, use this new handle value

HTML_CanGoBackAndForward_t

Purpose: page history status changed on the ability to go backwards and forward

HTML_ChangedTitle_t

Purpose: the page has a new title now

HTML_CloseBrowser_t

Purpose: The browser has been requested to close due to user interaction (usually from a javascript window.close() call)

HTML_FileOpenDialog_t

Purpose: when received show a file open dialog then call FileLoadDialogResponse with the file(s) the user selected.

HTML_FinishedRequest_t

Purpose: A page is finished loading

HTML_HideToolTip_t

Purpose: hide the tooltip you are showing

HTML_HorizontalScroll_t

Purpose: details on the visibility and size of the horizontal scrollbar

HTML_JSAlert_t

Purpose: show a Javascript alert dialog, call JSDialogResponse when the user dismisses this dialog (or right away to ignore it)

HTML_JSConfirm_t

Purpose: show a Javascript confirmation dialog, call JSDialogResponse when the user dismisses this dialog (or right away to ignore it)

HTML_LinkAtPosition_t

Purpose: response to GetLinkAtPosition call

HTML_NeedsPaint_t

Purpose: the browser has a pending paint

HTML_NewWindow_t

Purpose: a new html window is being created. IMPORTANT NOTE: at this time, the API does not allow you to acknowledge or render the contents of this new window, so the new window is always destroyed immediately. The URL and other parameters of the new window are passed here to give your application the opportunity to call CreateBrowser and set up a new browser in response to the attempted popup, if you wish to do so.

HTML_OpenLinkInNewTab_t

Purpose: a request to load this url in a new tab

HTML_SearchResults_t

Purpose: results from a search

HTML_SetCursor_t

Purpose: change the cursor to display

HTML_ShowToolTip_t

Purpose: show a tooltip

HTML_StartRequest_t

Purpose: The browser wanted to navigate to a new page NOTE - you MUST call AllowStartRequest in response to this callback

HTML_StatusText_t

Purpose: informational message from the browser

HTML_URLChanged_t

Purpose: the browser is navigating to a new url

HTML_UpdateToolTip_t

Purpose: update the text of an existing tooltip

HTML_VerticalScroll_t

Purpose: details on the visibility and size of the vertical scrollbar

HTTPCookieContainerHandle

Wraps the Steamworks HTTPCookieContainerHandle handle, a uint.

HTTPRequestCompleted_t

callbacks

HTTPRequestDataReceived_t

Payload of the Steamworks HTTPRequestDataReceived_t callback.

HTTPRequestHandle

Wraps the Steamworks HTTPRequestHandle handle, a uint.

HTTPRequestHeadersReceived_t

Payload of the Steamworks HTTPRequestHeadersReceived_t callback.

IPCFailure_t

Purpose: called when the callback system for this client is in an error state (and has flushed pending callbacks) When getting this message the client should disconnect from Steam, reset any stored Steam state and reconnect. This usually occurs in the rare event the Steam client has some kind of fatal error.

IPCountry_t

callbacks Purpose: The country of the user changed

InputActionSetHandle_t

Wraps the Steamworks InputActionSetHandle_t handle, a ulong.

InputAnalogActionData_t

The Steamworks InputAnalogActionData_t struct.

InputAnalogActionHandle_t

Wraps the Steamworks InputAnalogActionHandle_t handle, a ulong.

InputDigitalActionData_t

The Steamworks InputDigitalActionData_t struct.

InputDigitalActionHandle_t

Wraps the Steamworks InputDigitalActionHandle_t handle, a ulong.

InputHandle_t

Wraps the Steamworks InputHandle_t handle, a ulong.

InputMotionData_t

The Steamworks InputMotionData_t struct.

ItemInstalled_t

Purpose: a Workshop item has been installed or updated

JoinClanChatRoomCompletionResult_t

Purpose: a JoinClanChatRoom() call has finished

JoinPartyCallback_t

Steam has responded to the user request to join a party via the given Beacon ID. If successful, the connect string contains game-specific instructions to connect to the game with that party.

LeaderboardEntry_t

a single entry in a leaderboard, as returned by GetDownloadedLeaderboardEntry()

LeaderboardFindResult_t

Purpose: call result for finding a leaderboard, returned as a result of FindOrCreateLeaderboard() or FindLeaderboard() use CCallResult<> to map this async result to a member function

LeaderboardScoreUploaded_t

Purpose: call result indicating scores has been uploaded, returned as a result of UploadLeaderboardScore() use CCallResult<> to map this async result to a member function

LeaderboardScoresDownloaded_t

Purpose: call result indicating scores for a leaderboard have been downloaded and are ready to be retrieved, returned as a result of DownloadLeaderboardEntries() use CCallResult<> to map this async result to a member function

LeaderboardUGCSet_t

Purpose: call result indicating UGC has been uploaded, returned as a result of SetLeaderboardUGC()

LicensesUpdated_t

Purpose: Signaled whenever licenses change

LobbyChatMsg_t

Purpose: A chat message for this lobby has been sent use GetLobbyChatEntry( m_iChatID ) to retrieve the contents of this message

LobbyChatUpdate_t

Purpose: The lobby chat room state has changed this is usually sent when a user has joined or left the lobby

LobbyCreated_t

Purpose: Result of our request to create a Lobby m_eResult == k_EResultOK on success at this point, the lobby has been joined and is ready for use a LobbyEnter_t callback will also be received (since the local user is joining their own lobby)

LobbyDataUpdate_t

Purpose: The lobby metadata has changed if m_ulSteamIDMember is the steamID of a lobby member, use GetLobbyMemberData() to access per-user details if m_ulSteamIDMember == m_ulSteamIDLobby, use GetLobbyData() to access lobby metadata

LobbyEnter_t

Purpose: Sent on entering a lobby, or on failing to enter m_EChatRoomEnterResponse will be set to k_EChatRoomEnterResponseSuccess on success, or a higher value on failure (see enum EChatRoomEnterResponse)

LobbyGameCreated_t

Purpose: A game created a game for all the members of the lobby to join, as triggered by a SetLobbyGameServer() it's up to the individual clients to take action on this; the usual game behavior is to leave the lobby and connect to the specified game server

LobbyInvite_t

Purpose: Someone has invited you to join a Lobby normally you don't need to do anything with this, since the Steam UI will also display a '<user> has invited you to the lobby, join?' dialog if the user outside a game chooses to join, your game will be launched with the parameter "+connect_lobby <64-bit lobby id>", or with the callback GameLobbyJoinRequested_t if they're already in-game

LobbyKicked_t

Purpose: posted if a user is forcefully removed from a lobby can occur if a user loses connection to Steam

LobbyMatchList_t

Purpose: Number of matching lobbies found iterate the returned lobbies with GetLobbyByIndex(), from values 0 to m_nLobbiesMatching-1

LowBatteryPower_t

Purpose: Fired when running on a handheld PC or laptop with less than 10 minutes of battery is left, fires then every minute

MarketEligibilityResponse_t

Purpose: sent in response to ISteamUser::GetMarketEligibility

MatchMakingKeyValuePair_t

Store key/value pair used in matchmaking queries. Actually, the name Key/Value is a bit misleading. The "key" is better understood as "filter operation code" and the "value" is the operand to this filter operation. The meaning of the operand depends upon the filter.

MicroTxnAuthorizationResponse_t

Purpose: called when a user has responded to a microtransaction authorization request

NewUrlLaunchParameters_t

Purpose: posted after the user gains executes a Steam URL with command line or query parameters such as steam://run/<appid>//-commandline/?param1=value1&param2=value2&param3=value3 etc while the game is already running. The new params can be queried with GetLaunchQueryParam and GetLaunchCommandLine

NumberOfCurrentPlayers_t

Payload of the Steamworks NumberOfCurrentPlayers_t callback.

OverlayBrowserProtocolNavigation_t

Purpose: Dispatched when an overlay browser instance is navigated to a protocol/scheme registered by RegisterProtocolInOverlayBrowser()

P2PSessionConnectFail_t

callback notification - packets can't get through to the specified user via the SendP2PPacket() API all packets queued packets unsent at this point will be dropped further attempts to send will retry making the connection (but will be dropped if we fail again)

P2PSessionRequest_t

callbacks callback notification - a user wants to talk to us over the P2P channel via the SendP2PPacket() API in response, a call to AcceptP2PPacketsFromUser() needs to be made, if you want to talk with them

P2PSessionState_t

connection state to a specified user, returned by GetP2PSessionState() this is under-the-hood info about what's going on with a SendP2PPacket(), shouldn't be needed except for debuggin

PartyBeaconID_t

Wraps the Steamworks PartyBeaconID_t handle, a ulong.

PersonaStateChange_t

callbacks Purpose: called when a friends' status changes

PlaybackStatusHasChanged_t

callbacks

PublishedFileId_t

Wraps the Steamworks PublishedFileId_t handle, a ulong.

PublishedFileUpdateHandle_t

Wraps the Steamworks PublishedFileUpdateHandle_t handle, a ulong.

RTime32

Wraps the Steamworks RTime32 handle, a uint.

RemotePlayCursorID_t

Wraps the Steamworks RemotePlayCursorID_t handle, a uint.

RemotePlayInputKey_t

Key event data, valid when m_eType is k_ERemotePlayInputKeyDown or k_ERemotePlayInputKeyUp

RemotePlayInputMouseMotion_t

Mouse motion event data, valid when m_eType is k_ERemotePlayInputMouseMotion

RemotePlayInputMouseWheel_t

Mouse wheel event data, valid when m_eType is k_ERemotePlayInputMouseWheel

RemotePlayInput_t

A Remote Play input event, as defined in isteamremoteplay.h and filled in by GetInput(RemotePlayInput_t[], uint). m_eType indicates which payload in m_val is valid.

RemotePlayInput_t.OptionValue

The C++ union of per-event payloads; read the one m_eType names.

RemotePlaySessionID_t

Wraps the Steamworks RemotePlaySessionID_t handle, a uint.

RemoteStorageDeletePublishedFileResult_t

k_iSteamRemoteStorageCallbacks + 10 is deprecated! Do not reuse Purpose: The result of a call to DeletePublishedFile()

RemoteStorageDownloadUGCResult_t

Purpose: The result of a call to UGCDownload()

RemoteStorageEnumeratePublishedFilesByUserActionResult_t

Payload of the Steamworks RemoteStorageEnumeratePublishedFilesByUserActionResult_t callback.

RemoteStorageEnumerateUserPublishedFilesResult_t

Purpose: The result of a call to EnumerateUserPublishedFiles()

RemoteStorageEnumerateUserSharedWorkshopFilesResult_t

Payload of the Steamworks RemoteStorageEnumerateUserSharedWorkshopFilesResult_t callback.

RemoteStorageEnumerateUserSubscribedFilesResult_t

Purpose: The result of a call to EnumerateSubscribePublishedFiles()

RemoteStorageEnumerateWorkshopFilesResult_t

Payload of the Steamworks RemoteStorageEnumerateWorkshopFilesResult_t callback.

RemoteStorageFileReadAsyncComplete_t

Purpose: Called when a FileReadAsync completes

RemoteStorageFileShareResult_t

callbacks Purpose: The result of a call to FileShare()

RemoteStorageFileWriteAsyncComplete_t

Purpose: Called when a FileWriteAsync completes

RemoteStorageGetPublishedFileDetailsResult_t

Purpose: The result of a call to GetPublishedFileDetails()

RemoteStorageGetPublishedItemVoteDetailsResult_t

Purpose: The result of GetPublishedItemVoteDetails

RemoteStorageLocalFileChange_t

Purpose: one or more files for this app have changed locally after syncing to remote session changes Note: only posted if this happens DURING the local app session

RemoteStoragePublishFileProgress_t

Purpose: Called periodically while a PublishWorkshopFile is in progress

RemoteStoragePublishFileResult_t

k_iSteamRemoteStorageCallbacks + 8 is deprecated! Do not reuse Purpose: The result of a call to PublishFile()

RemoteStoragePublishedFileDeleted_t

Purpose: Published file that a user owns was deleted (from within the app or the web)

RemoteStoragePublishedFileSubscribed_t

Purpose: User subscribed to a file for the app (from within the app or on the web)

RemoteStoragePublishedFileUnsubscribed_t

Purpose: User unsubscribed from a file for the app (from within the app or on the web)

RemoteStoragePublishedFileUpdated_t

Purpose: Called when the content for a published file is updated

RemoteStorageSetUserPublishedFileActionResult_t

Payload of the Steamworks RemoteStorageSetUserPublishedFileActionResult_t callback.

RemoteStorageSubscribePublishedFileResult_t

Purpose: The result of a call to SubscribePublishedFile()

RemoteStorageUnsubscribePublishedFileResult_t

Purpose: The result of a call to UnsubscribePublishedFile()

RemoteStorageUpdatePublishedFileResult_t

Purpose: The result of a call to CommitPublishedFileUpdate()

RemoteStorageUpdateUserPublishedItemVoteResult_t

Purpose: The result of a call to UpdateUserPublishedItemVote()

RemoteStorageUserVoteDetails_t

Purpose: The result of a call to GetUserPublishedItemVoteDetails()

RemoveAppDependencyResult_t

Purpose: The result of a call to RemoveAppDependency

RemoveUGCDependencyResult_t

Purpose: The result of a call to RemoveDependency

ReservationNotificationCallback_t

Someone has used the beacon to join your party - they are in-flight now and we've reserved one of the open slots for them. You should confirm when they join your party by calling OnReservationCompleted(). Otherwise, Steam may timeout their reservation eventually.

SNetListenSocket_t

Wraps the Steamworks SNetListenSocket_t handle, a uint.

SNetSocket_t

Wraps the Steamworks SNetSocket_t handle, a uint.

ScreenshotHandle

Wraps the Steamworks ScreenshotHandle handle, a uint.

ScreenshotReady_t

callbacks Purpose: Screenshot successfully written or otherwise added to the library and can now be tagged

ScreenshotRequested_t

Purpose: Screenshot has been requested by the user. Only sent if HookScreenshots() has been called, in which case Steam will not take the screenshot itself.

SetUserItemVoteResult_t

Purpose: The result of a call to SetUserItemVote()

SocketStatusCallback_t

callback notification - status of a socket has changed used as part of the CreateListenSocket() / CreateP2PConnectionSocket()

StartPlaytimeTrackingResult_t

Purpose: The result of a call to StartPlaytimeTracking()

SteamAPICallCompleted_t

Purpose: called when a SteamAsyncCall_t has completed (or failed)

SteamAPICall_t

Wraps the Steamworks SteamAPICall_t handle, a ulong.

SteamCallbackMessage

A raw Steam callback as delivered to the OnCallback event. Payload points into a dispatcher-owned buffer that is valid only during the handler call: decode it there with As<T>() and copy out any data that must outlive the call.

SteamDatagramGameCoordinatorServerLogin

The Steamworks SteamDatagramGameCoordinatorServerLogin struct.

SteamDatagramHostedAddress

Network-routable identifier for a service hosted behind the Steam Datagram Relay. The blob is deliberately opaque: the relays know how to route it, and clients should not inspect its contents.

SteamDatagramRelayAuthTicket

A parsed Steam Datagram Relay auth ticket, filled in by ReceivedRelayAuthTicket(IntPtr, int, out SteamDatagramRelayAuthTicket) and FindRelayAuthTicketForServer(ref SteamNetworkingIdentity, int, out SteamDatagramRelayAuthTicket). Treat it as read-only: tickets are generated and signed on the game's backend.

SteamIPAddress_t

An IPv4 or IPv6 address, as defined in steamtypes.h. m_eType indicates which is valid. Read and write the IPv6 bytes with GetIPv6() and SetIPv6(byte[]).

SteamInputActionEvent_t

A controller action state change, passed to the SteamInputActionEventCallbackPointer installed with EnableActionEventCallbacks(SteamInputActionEventCallbackPointer). eEventType indicates which payload in m_val is valid.

SteamInputActionEvent_t.AnalogAction_t

The payload of an analog action event.

SteamInputActionEvent_t.DigitalAction_t

The payload of a digital action event.

SteamInputActionEvent_t.OptionValue

The C++ union of the two payloads; read the one eEventType names.

SteamInputConfigurationLoaded_t

Purpose: called when a controller configuration has been loaded, will fire once per controller per focus change for Steam Input enabled controllers

SteamInputDeviceConnected_t

Purpose: called when a new controller has been connected, will fire once per controller if multiple new controllers connect in the same frame

SteamInputDeviceDisconnected_t

Purpose: called when a new controller has been connected, will fire once per controller if multiple new controllers connect in the same frame

SteamInputGamepadSlotChange_t

Purpose: called when controller gamepad slots change - on Linux/macOS these slots are shared for all running apps.

SteamInventoryDefinitionUpdate_t

A SteamInventoryDefinitionUpdate_t callback is triggered whenever item definitions have been updated, which could be in response to LoadItemDefinitions() or any other async request which required a definition update in order to process results from the server.

SteamInventoryEligiblePromoItemDefIDs_t

Returned

SteamInventoryFullUpdate_t

SteamInventoryFullUpdate_t callbacks are triggered when GetAllItems successfully returns a result which is newer / fresher than the last known result. (It will not trigger if the inventory hasn't changed, or if results from two overlapping calls are reversed in flight and the earlier result is already known to be stale/out-of-date.) The normal ResultReady callback will still be triggered immediately afterwards; this is an additional notification for your convenience.

SteamInventoryRequestPricesResult_t

Triggered from RequestPrices

SteamInventoryResultReady_t

SteamInventoryResultReady_t callbacks are fired whenever asynchronous results transition from "Pending" to "OK" or an error state. There will always be exactly one callback per handle.

SteamInventoryResult_t

Wraps the Steamworks SteamInventoryResult_t handle, a int.

SteamInventoryStartPurchaseResult_t

Triggered from StartPurchase call

SteamInventoryUpdateHandle_t

Wraps the Steamworks SteamInventoryUpdateHandle_t handle, a ulong.

SteamItemDef_t

Wraps the Steamworks SteamItemDef_t handle, a int.

SteamItemDetails_t

The Steamworks SteamItemDetails_t struct.

SteamItemInstanceID_t

Wraps the Steamworks SteamItemInstanceID_t handle, a ulong.

SteamLeaderboardEntries_t

Wraps the Steamworks SteamLeaderboardEntries_t handle, a ulong.

SteamLeaderboard_t

Wraps the Steamworks SteamLeaderboard_t handle, a ulong.

SteamNetAuthenticationStatus_t

A struct used to describe our readiness to participate in authenticated, encrypted communication. In order to do this we need:

The list of trusted CA certificates that might be relevant for this app.
A valid certificate issued by a CA. This callback is posted whenever the state of our readiness changes.

SteamNetConnectionInfo_t

Describe the state of a connection.

SteamNetConnectionRealTimeLaneStatus_t

Quick status of a particular lane

SteamNetConnectionRealTimeStatus_t

Quick connection state, pared down to something you could call more frequently without it being too big of a perf hit.

SteamNetConnectionStatusChangedCallback_t

Callback struct used to notify when a connection has changed state This callback is posted whenever a connection is created, destroyed, or changes state. The m_info field will contain a complete description of the connection at the time the change occurred and the callback was posted. In particular, m_eState will have the new connection state. You will usually need to listen for this callback to know when:

A new connection arrives on a listen socket. m_info.m_hListenSocket will be set, m_eOldState = k_ESteamNetworkingConnectionState_None, and m_info.m_eState = k_ESteamNetworkingConnectionState_Connecting. See ISteamNetworkigSockets::AcceptConnection.
A connection you initiated has been accepted by the remote host. m_eOldState = k_ESteamNetworkingConnectionState_Connecting, and m_info.m_eState = k_ESteamNetworkingConnectionState_Connected. Some connections might transition to k_ESteamNetworkingConnectionState_FindingRoute first.
A connection has been actively rejected or closed by the remote host. m_eOldState = k_ESteamNetworkingConnectionState_Connecting or k_ESteamNetworkingConnectionState_Connected, and m_info.m_eState = k_ESteamNetworkingConnectionState_ClosedByPeer. m_info.m_eEndReason and m_info.m_szEndDebug will have for more details. NOTE: upon receiving this callback, you must still destroy the connection using ISteamNetworkingSockets::CloseConnection to free up local resources. (The details passed to the function are not used in this case, since the connection is already closed.)
A problem was detected with the connection, and it has been closed by the local host. The most common failure is timeout, but other configuration or authentication failures can cause this. m_eOldState = k_ESteamNetworkingConnectionState_Connecting or k_ESteamNetworkingConnectionState_Connected, and m_info.m_eState = k_ESteamNetworkingConnectionState_ProblemDetectedLocally. m_info.m_eEndReason and m_info.m_szEndDebug will have for more details. NOTE: upon receiving this callback, you must still destroy the connection using ISteamNetworkingSockets::CloseConnection to free up local resources. (The details passed to the function are not used in this case, since the connection is already closed.) Remember that callbacks are posted to a queue, and networking connections can change at any time. It is possible that the connection has already changed state by the time you process this callback. Also note that callbacks will be posted when connections are created and destroyed by your own API calls.

SteamNetworkPingLocation_t

Ping location / measurement Object that describes a "location" on the Internet with sufficient detail that we can reasonably estimate an upper bound on the ping between the two hosts, even if a direct route between the hosts is not possible, and the connection must be routed through the Steam Datagram Relay network. This does not contain any information that identifies the host. Indeed, if two hosts are in the same building or otherwise have nearly identical networking characteristics, then it's valid to use the same location object for both of them. NOTE: This object should only be used in the same process! Do not serialize it, send it over the wire, or persist it in a file or database! If you need to do that, convert it to a string representation using the methods in ISteamNetworkingUtils().

SteamNetworkingConfigValue_t

One configuration option passed to a listen-socket or connection creation call (e.g. CreateListenSocketIP(ref SteamNetworkingIPAddr, int, SteamNetworkingConfigValue_t[])). Options passed at creation apply before the object does anything, which setting them right after creation cannot guarantee.

SteamNetworkingConfigValue_t.OptionValue

The C++ union of possible values: every member overlays the same 8 bytes, and m_eDataType names the live one.

SteamNetworkingErrMsg

The C++ char[k_cchMaxSteamNetworkingErrMsg] buffer (1024 bytes) that Steam fills with an English diagnostic message, meant for logs rather than UI. Read it with ToString().

SteamNetworkingFakeIPResult_t

Callback struct used to notify when a connection has changed state A struct used to describe a "fake IP" we have been assigned to use as an identifier. This callback is posted when ISteamNetworkingSoockets::BeginAsyncRequestFakeIP completes. See also ISteamNetworkingSockets::GetFakeIP

SteamNetworkingIPAddr

An IP address and port. The address is always stored as IPv6, with IPv4 as an IPv4-mapped address (RFC 4291 §2.5.5.2: aa.bb.cc.dd is ::ffff:aabb:ccdd). Packed to 1 like the C++ struct, so it is exactly 18 bytes: 16 address bytes, then the port. Methods call the SDK's flat accessors, so they behave exactly like the C++ ones.

SteamNetworkingIdentity

The identity of a network host: a SteamID, IP address, generic string or bytes, and so on. Every identity has a string form (see ToString()), which is what goes on the wire in several places, so older code can carry identity types it does not understand. The payload is not exposed as fields: read and write it through the methods.

SteamNetworkingMessage_t

A network message. Message objects always live in native memory and are handed out as pointers (e.g. by ReceiveMessagesOnConnection(HSteamNetConnection, IntPtr[], int)). Read one with FromIntPtr(IntPtr), and pass the original pointer to Release(IntPtr) when finished. Every message must be released.

SteamNetworkingMessagesSessionFailed_t

Posted when we fail to establish a connection, or we detect that communications have been disrupted it an unusual way. There is no notification when a peer proactively closes the session. ("Closed by peer" is not a concept of UDP-style communications, and SteamNetworkingMessages is primarily intended to make porting UDP code easy.) Remember: callbacks are asynchronous. See notes on SendMessageToUser, and k_nSteamNetworkingSend_AutoRestartBrokenSession in particular. Also, if a session times out due to inactivity, no callbacks will be posted. The only way to detect that this is happening is that querying the session state may return none, connecting, and findingroute again.

SteamNetworkingMessagesSessionRequest_t

Callbacks Posted when a remote host is sending us a message, and we do not already have a session with them

SteamNetworkingMicroseconds

Wraps the Steamworks SteamNetworkingMicroseconds handle, a long.

SteamNetworkingPOPID

Wraps the Steamworks SteamNetworkingPOPID handle, a uint.

SteamParamStringArray_t

Purpose: Structure that contains an array of const char * strings and the number of those strings

SteamParentalSettingsChanged_t

Purpose: Callback for querying UGC

SteamPartyBeaconLocation_t

The Steamworks SteamPartyBeaconLocation_t struct.

SteamRelayNetworkStatus_t

A struct used to describe our readiness to use the relay network. To do this we first need to fetch the network configuration, which describes what POPs are available.

SteamRemotePlaySessionAvatarLoaded_t

Payload of the Steamworks SteamRemotePlaySessionAvatarLoaded_t callback.

SteamRemotePlaySessionConnected_t

callbacks

SteamRemotePlaySessionDisconnected_t

Payload of the Steamworks SteamRemotePlaySessionDisconnected_t callback.

SteamRemotePlayTogetherGuestInvite_t

Payload of the Steamworks SteamRemotePlayTogetherGuestInvite_t callback.

SteamServerConnectFailure_t

Purpose: called when a connection attempt has failed this will occur periodically if the Steam client is not connected, and has failed in it's retry to establish a connection

SteamServersConnected_t

callbacks Purpose: Called when an authenticated connection to the Steam back-end has been established. This means the Steam client now has a working connection to the Steam servers. Usually this will have occurred before the game has launched, and should only be seen if the user has dropped connection due to a networking issue or a Steam server update.

SteamServersDisconnected_t

Purpose: called if the client has lost connection to the Steam servers real-time services will be disabled until a matching SteamServersConnected_t has been posted

SteamShutdown_t

called when Steam wants to shutdown

SteamTimelineEventRecordingExists_t

Purpose: Callback for querying UGC

SteamTimelineGamePhaseRecordingExists_t

Purpose: Callback for querying UGC

SteamUGCDetails_t

Details for a single published file/UGC

SteamUGCQueryCompleted_t

Purpose: Callback for querying UGC

SteamUGCRequestUGCDetailsResult_t

Purpose: Callback for requesting details on one piece of UGC

StopPlaytimeTrackingResult_t

Purpose: The result of a call to StopPlaytimeTracking()

StoreAuthURLResponse_t

Purpose: sent to your game in response to ISteamUser::RequestStoreAuthURL

SubmitItemUpdateResult_t

Purpose: result for ISteamUGC::SubmitItemUpdate()

TimedTrialStatus_t

Purpose: called for games in Timed Trial mode

TimelineEventHandle_t

Wraps the Steamworks TimelineEventHandle_t handle, a ulong.

UGCFileWriteStreamHandle_t

Wraps the Steamworks UGCFileWriteStreamHandle_t handle, a ulong.

UGCHandle_t

Wraps the Steamworks UGCHandle_t handle, a ulong.

UGCQueryHandle_t

Wraps the Steamworks UGCQueryHandle_t handle, a ulong.

UGCUpdateHandle_t

Wraps the Steamworks UGCUpdateHandle_t handle, a ulong.

UnreadChatMessagesChanged_t

Purpose: Invoked when the status of unread messages changes

UserAchievementIconFetched_t

Purpose: Callback indicating that an achievement icon has been fetched

UserAchievementStored_t

Purpose: result of a request to store the achievements for a game, or an "indicate progress" call. If both m_nCurProgress and m_nMaxProgress are zero, that means the achievement has been fully unlocked.

UserFavoriteItemsListChanged_t

Purpose: result of AddItemToFavorites() or RemoveItemFromFavorites()

UserStatsReceived_t

callbacks Purpose: called when the latests stats and achievements have been received from the server

UserStatsStored_t

Purpose: result of a request to store the user stats for a game

UserStatsUnloaded_t

Purpose: Callback indicating that a user's stats have been unloaded. Call RequestUserStats again to access stats for this user

UserSubscribedItemsListChanged_t

Purpose: signal that the list of subscribed items changed

ValidateAuthTicketResponse_t

callback for BeginAuthSession

VolumeHasChanged_t

Payload of the Steamworks VolumeHasChanged_t callback.

WorkshopEULAStatus_t

Purpose: Status of the user's acceptable/rejection of the app's specific Workshop EULA

servernetadr_t

A game server's IPv4 address, connection port and query port, as the server browser reports them.

Enums

AudioPlayback_Status

Purpose:

CGameID.EGameIDType

The kind of entity a CGameID identifies.

EAccountType

Steam account types

EActivateGameOverlayToWebPageMode

Purpose: Tells Steam where to place the browser window inside the overlay

EAuthSessionResponse

Callback values for callback ValidateAuthTicketResponse_t which is a response to BeginAuthSession

EBeginAuthSessionResult

results from BeginAuthSession

EBetaBranchFlags

The Steamworks EBetaBranchFlags enumeration.

EBroadcastUploadResult

Purpose: Broadcast upload result details

EChatEntryType

Purpose: Chat Entry Types (previously was only friend-to-friend message types)

EChatMemberStateChange

Purpose: Used in ChatInfo messages - fields specific to a chat member - must fit in a uint32

EChatRoomEnterResponse

Purpose: Chat Room Enter Responses

EChatSteamIDInstanceFlags

Special flags for Chat accounts - they go in the top 8 bits of the steam ID's "instance", leaving 12 for the actual instances

ECheckFileSignature

results for CheckFileSignature

ECommunityProfileItemProperty

The Steamworks ECommunityProfileItemProperty enumeration.

ECommunityProfileItemType

Purpose: See GetProfileItemPropertyString and GetProfileItemPropertyUint

EControllerActionOrigin

The Steamworks EControllerActionOrigin enumeration.

EControllerHapticLocation

Only used in the Legacy haptic call family (Steam Input api). For modern haptic locations we are using ESteamControllerPad.

EControllerHapticType

The Steamworks EControllerHapticType enumeration.

EDenyReason

Result codes to GSHandleClientDeny/Kick

EDurationControlNotification

describes which notification timer has expired, for steam china duration control feature WARNING: DO NOT RENUMBER

EDurationControlOnlineState

Specifies a game's online state in relation to duration control

EDurationControlProgress

describes XP / progress restrictions to apply for games with duration control / anti-indulgence enabled for minor Steam China users. WARNING: DO NOT RENUMBER

EFailureType

The Steamworks EFailureType enumeration.

EFloatingGamepadTextInputMode

The Steamworks EFloatingGamepadTextInputMode enumeration.

EFriendFlags

Purpose: flags for enumerating friends list, or quickly checking a the relationship between users

EFriendRelationship

Purpose: set of relationships to other users

EGCResults

list of possible return values from the ISteamGameCoordinator API

EGamePerformanceSetting

Games can specify what settings the user has selected or has been selected by default based on the user's machine.

EGamepadTextInputLineMode

Controls number of allowed lines for the Big Picture gamepad text entry

EGamepadTextInputMode

Input modes for the Big Picture gamepad text entry

EHTMLKeyModifiers

The Steamworks EHTMLKeyModifiers enumeration.

EHTMLMouseButton

The Steamworks EHTMLMouseButton enumeration.

EHTMLMouseCursor

The Steamworks EHTMLMouseCursor enumeration.

EHTTPMethod

HTTP related types This enum is used in client API methods, do not re-number existing values.

EHTTPStatusCode

HTTP Status codes that the server can send in response to a request, see rfc2616 section 10.3 for descriptions of each of these.

EInputActionOrigin

Note: Please do not use action origins as a way to identify controller types. There is no guarantee that they will be added in a contiguous manner - use GetInputTypeForHandle instead. Versions of Steam that add new controller types in the future will extend this enum so if you're using a lookup table please check the bounds of any origins returned by Steam.

EInputSourceMode

The Steamworks EInputSourceMode enumeration.

EItemPreviewType

The Steamworks EItemPreviewType enumeration.

EItemState

The Steamworks EItemState enumeration.

EItemStatistic

The Steamworks EItemStatistic enumeration.

EItemUpdateStatus

The Steamworks EItemUpdateStatus enumeration.

ELeaderboardDataRequest

type of data request, when downloading leaderboard entries

ELeaderboardDisplayType

the display type (used by the Steam Community web site) for a leaderboard

ELeaderboardSortMethod

the sort order of a leaderboard

ELeaderboardUploadScoreMethod

The Steamworks ELeaderboardUploadScoreMethod enumeration.

ELobbyComparison

lobby search filter tools

ELobbyDistanceFilter

lobby search distance. Lobby results are sorted from closest to farthest.

ELobbyType

lobby type description

EMarketNotAllowedReasonFlags

Purpose: Reasons a user may not use the Community Market. Used in MarketEligibilityResponse_t.

EMatchMakingServerResponse

The Steamworks EMatchMakingServerResponse enumeration.

ENotificationPosition

Purpose: Possible positions to tell the overlay to show notifications in

EOverlayToStoreFlag

These values are passed as parameters to the store

EP2PSend

SendP2PPacket() send types Typically k_EP2PSendUnreliable is what you want for UDP-like packets, k_EP2PSendReliable for TCP-like packets

EP2PSessionError

list of possible errors returned by SendP2PPacket() API these will be posted in the P2PSessionConnectFail_t callback

EParentalFeature

Feature types for parental settings These end up in a 32-bit bitfield so we're limited on how many we can have.

EPersonaChange

used in PersonaStateChange_t::m_nChangeFlags to describe what's changed about a user these flags describe what the client has learned has changed recently, so on startup you'll see a name, avatar & relationship change for every friend

EPersonaState

Purpose: list of states a friend can be in

ERemotePlayInputType

Purpose: The type of input in ERemotePlayInput_t

ERemotePlayKeyModifier

Purpose: Key modifier in ERemotePlayInput_t

ERemotePlayMouseButton

Purpose: Mouse buttons in ERemotePlayInput_t

ERemotePlayMouseWheelDirection

Purpose: Mouse wheel direction in ERemotePlayInput_t

ERemotePlayScancode

Purpose: Key scancode in ERemotePlayInput_t This is a USB scancode value as defined for the Keyboard/Keypad Page (0x07) This enumeration isn't a complete list, just the most commonly used keys.

ERemoteStorageFilePathType

The Steamworks ERemoteStorageFilePathType enumeration.

ERemoteStorageLocalFileChange

The Steamworks ERemoteStorageLocalFileChange enumeration.

ERemoteStoragePlatform

The Steamworks ERemoteStoragePlatform enumeration.

ERemoteStoragePublishedFileVisibility

The Steamworks ERemoteStoragePublishedFileVisibility enumeration.

EResult

General result codes

ESNetSocketConnectionType

describes how the socket is currently connected

ESNetSocketState

connection progress indicators, used by CreateP2PConnectionSocket()

EServerMode

The Steamworks EServerMode enumeration.

ESteamAPICallFailure

Steam API call failure results

ESteamAPIInitResult

----------------------------------------------------------------------------------------------------------------------------------------------------------// Steam API setup & shutdown These functions manage loading, initializing and shutdown of the steamclient.dll ----------------------------------------------------------------------------------------------------------------------------------------------------------//

ESteamControllerLEDFlag

The Steamworks ESteamControllerLEDFlag enumeration.

ESteamControllerPad

The Steamworks ESteamControllerPad enumeration.

ESteamDeviceFormFactor

Purpose: The form factor of a device

ESteamHardwareDefaultConfig

Default game settings profile

ESteamHardwareType

Steam device list

ESteamIPType

The Steamworks ESteamIPType enumeration.

ESteamIPv6ConnectivityProtocol

The Steamworks ESteamIPv6ConnectivityProtocol enumeration.

ESteamIPv6ConnectivityState

For the above transport protocol, what do we think the local machine's connectivity to the internet over ipv6 is like

ESteamInputActionEventType

The Steamworks ESteamInputActionEventType enumeration.

ESteamInputConfigurationEnableType

Individual values are used by the GetSessionInputConfigurationSettings bitmask

ESteamInputGlyphSize

These values are passed into GetGlyphPNGForActionOrigin

ESteamInputGlyphStyle

The Steamworks ESteamInputGlyphStyle enumeration.

ESteamInputLEDFlag

These values are passed into SetLEDColor

ESteamInputType

The Steamworks ESteamInputType enumeration.

ESteamItemFlags

The Steamworks ESteamItemFlags enumeration.

ESteamNetConnectionEnd

Enumerate various causes of connection termination. These are designed to work similar to HTTP error codes: the numeric range gives you a rough classification as to the source of the problem.

ESteamNetworkingAvailability

Describe the status of a particular network resource

ESteamNetworkingConfigDataType

Different configuration values have different data types

ESteamNetworkingConfigScope

Configuration values Configuration values can be applied to different types of objects.

ESteamNetworkingConfigValue

Configuration options

ESteamNetworkingConnectionState

Connection status High level connection status

ESteamNetworkingFakeIPType

"Fake IPs" are assigned to hosts, to make it easier to interface with older code that assumed all hosts will have an IPv4 address

ESteamNetworkingGetConfigValueResult

Return value of ISteamNetworkintgUtils::GetConfigValue

ESteamNetworkingIdentityType

Describing network hosts Different methods of describing the identity of a network host

ESteamNetworkingSocketsDebugOutputType

Debug output Detail level for diagnostic output callback. See ISteamNetworkingUtils::SetDebugOutputFunction

ESteamPartyBeaconLocationData

The Steamworks ESteamPartyBeaconLocationData enumeration.

ESteamPartyBeaconLocationType

Purpose: Functions for quickly creating a Party with friends or acquaintances, EG from chat rooms.

ETextFilteringContext

The context where text filtering is being done

ETimelineEventClipPriority

Used in AddTimelineEvent, where Featured events will be offered before Standard events

ETimelineGameMode

callbacks Controls the color of the timeline bar segments. The value names listed here map to a multiplayer game, where the user starts a game (in menus), then joins a multiplayer session that first has a character selection lobby then finally the multiplayer session starts. However, you can also map these values to any type of game. In a single player game where you visit towns & dungeons, you could set k_ETimelineGameMode_Menus when the player is in a town buying items, k_ETimelineGameMode_Staging for when a dungeon is loading and k_ETimelineGameMode_Playing for when inside the dungeon fighting monsters.

EUGCContentDescriptorID

The Steamworks EUGCContentDescriptorID enumeration.

EUGCMatchingUGCType

Matching UGC types for queries

EUGCQuery

Combination of sorting and filtering for queries across all UGC

EUGCReadAction

The Steamworks EUGCReadAction enumeration.

EUniverse

Steam universes. Each universe is a self-contained Steam instance.

EUserHasLicenseForAppResult

results from UserHasLicenseForApp

EUserUGCList

Different lists of published UGC for a user. If the current logged in user is different than the specified user, then some options may not be allowed.

EUserUGCListSortOrder

Sort order for user published UGC lists (defaults to creation order descending)

EVRScreenshotType

The Steamworks EVRScreenshotType enumeration.

EVoiceResult

Error codes for use with the voice functions

EWorkshopEnumerationType

The Steamworks EWorkshopEnumerationType enumeration.

EWorkshopFileAction

The Steamworks EWorkshopFileAction enumeration.

EWorkshopFileType

The Steamworks EWorkshopFileType enumeration.

EWorkshopVideoProvider

The Steamworks EWorkshopVideoProvider enumeration.

EWorkshopVote

The Steamworks EWorkshopVote enumeration.

EXboxOrigin

The Steamworks EXboxOrigin enumeration.

SteamDispatchMode

Who reads a Steam pipe's callbacks after initialization.

Delegates

FSteamNetworkingSocketsDebugOutput

Receives debug output from SteamNetworkingSockets. Install it, together with the verbosity level, through SetDebugOutputFunction(ESteamNetworkingSocketsDebugOutputType, FSteamNetworkingSocketsDebugOutput). May be called from any thread.

The target must be a static method marked [AOT.MonoPInvokeCallback(typeof(FSteamNetworkingSocketsDebugOutput))]: IL2CPP only generates a native-callable wrapper for such methods, and without one the call fails at runtime, not at build time. Catch every exception in the handler. An exception that unwinds into Steam causes undefined behavior.

FnSteamNetAuthenticationStatusChanged

The Steamworks FnSteamNetAuthenticationStatusChanged callback function pointer.

FnSteamNetConnectionStatusChanged

The Steamworks FnSteamNetConnectionStatusChanged callback function pointer.

FnSteamNetworkingFakeIPResult

The Steamworks FnSteamNetworkingFakeIPResult callback function pointer.

FnSteamNetworkingMessagesSessionFailed

The Steamworks FnSteamNetworkingMessagesSessionFailed callback function pointer.

FnSteamNetworkingMessagesSessionRequest

The Steamworks FnSteamNetworkingMessagesSessionRequest callback function pointer.

FnSteamRelayNetworkStatusChanged

The Steamworks FnSteamRelayNetworkStatusChanged callback function pointer.

ISteamMatchmakingPingResponse.ServerFailedToRespondHandler

The server failed to respond to the ping.

ISteamMatchmakingPingResponse.ServerRespondedHandler

The server responded with its current details.

ISteamMatchmakingPlayersResponse.AddPlayerToListHandler

One player on the server.

ISteamMatchmakingPlayersResponse.PlayersFailedToRespondHandler

The server failed to return its player list.

ISteamMatchmakingPlayersResponse.PlayersRefreshCompleteHandler

Every player has been reported; no further ISteamMatchmakingPlayersResponse.AddPlayerToListHandler calls follow.

ISteamMatchmakingRulesResponse.RulesFailedToRespondHandler

The server failed to return its rules.

ISteamMatchmakingRulesResponse.RulesRefreshCompleteHandler

Every rule has been reported; no further ISteamMatchmakingRulesResponse.RulesRespondedHandler calls follow.

ISteamMatchmakingRulesResponse.RulesRespondedHandler

One rule the server has set.

ISteamMatchmakingServerFriendsResponse.AddFriendToListHandler

One friend who has played on the server.

ISteamMatchmakingServerFriendsResponse.FriendsFailedToRespondHandler

The server failed to return its friends list.

ISteamMatchmakingServerFriendsResponse.FriendsRefreshCompleteHandler

Every friend has been reported; no further ISteamMatchmakingServerFriendsResponse.AddFriendToListHandler calls follow.

ISteamMatchmakingServerListResponse.RefreshCompleteHandler

The list refresh has finished.

ISteamMatchmakingServerListResponse.ServerFailedToRespondHandler

A server in the list failed to respond.

ISteamMatchmakingServerListResponse.ServerRespondedHandler

A server in the list responded; read its details with GetServerDetails(HServerListRequest, int).

PFNPreMinidumpCallback

The Steamworks PFNPreMinidumpCallback callback function pointer.

SteamAPIWarningMessageHook_t

Receives Steam API warnings and diagnostic messages. Install it with SetWarningMessageHook(SteamAPIWarningMessageHook_t).

Steam calls it from native code, so the method that implements it must be static and carry [AOT.MonoPInvokeCallback(typeof(SteamAPIWarningMessageHook_t))]. IL2CPP builds a native entry point only for such a method; any other method fails at runtime, not at build time. The handler must catch every exception, because one unwinding into Steam's stack is undefined behavior.

SteamAPI_CheckCallbackRegistered_t

Steam-internal hook that reports whether a callback is registered for a callback id. No API in this package accepts one; the SDK takes it only through a private ISteamClient method. As with any delegate that Steam calls, back it with a static method that carries [AOT.MonoPInvokeCallback(typeof(SteamAPI_CheckCallbackRegistered_t))] and catches every exception.

SteamInputActionEventCallbackPointer

Receives each Steam Input action event; install it with EnableActionEventCallbacks(SteamInputActionEventCallbackPointer). It runs synchronously inside RunFrame(bool) or Steam's own callback dispatch, on whichever thread made that call.

Steam calls it from native code, so the method behind it must be static and carry [AOT.MonoPInvokeCallback(typeof(SteamInputActionEventCallbackPointer))]: IL2CPP only builds a native entry point for such a method, and otherwise fails at runtime rather than at build time. Catch every exception in the handler. An exception that unwinds into Steam's stack causes undefined behavior.