⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

version unknown

steam-debug

kmturley@kmturley⭐ 7 stars· last commit 1mo ago· 0 open issues

Inspect, debug, and inject custom code into a running Steam client — desktop (macOS, Linux, Windows) or Steam Deck over the network — through its Chromium Embedded Framework (CEF) Chrome DevTools Protocol endpoint. Use when developing Steam UI plugins, mods, themes, or integrations — injecting CSS/JS to try a change, locating webpack modules and obfuscated class names, reading React or SteamUIStore state, inspecting Big Picture / Quick Access Menu windows, screenshotting what actually rendered,

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐ 7 on GitHubGitHub ↗

New / niche

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

steam-debug

A Claude skill and standalone CLI for inspecting, debugging, and injecting code into a running Steam client — desktop or Steam Deck — via the Chrome DevTools Protocol (CDP).

Steam's UI is a Chromium Embedded Framework (CEF) app. Launched with debug flags it exposes the same protocol browser DevTools uses, so the entire Steam UI can be inspected and modified at runtime like a web page. steam-debug.mjs wraps that protocol into focused commands — read React state, search webpack modules, resolve minified class names, inspect computed CSS, drive navigation, stream logs, and inject custom CSS/JS.

Built for plugin, theme, and integration development against Steam's UI.

Works on desktop and Steam Deck. Same commands for both — a desktop client on macOS, Linux or Windows, and a Deck over the network via --host. Both are exercised by the test suite, and any command can run against both at once. See reference/remote.md.

Scope. This is a debugging and development tool. Injection is per-session and disappears on reload, by design — it exists so you can try a change and see what happens.

Out of scope: making a change persist or load on startup, packaging or distributing plugins, and anything that runs unattended inside someone's client. That belongs in a plugin loader. The boundary is simple — this helps you find out what is going on and try a change; making a change stick is someone else's job.


Using with Claude

Place this directory at ~/.claude/skills/steam-debug/. Claude Code discovers it via SKILL.md.

Describe the task in plain language; Claude selects the commands, interprets output, and follows the operating procedure in SKILL.md:

"Why is my injected CSS not showing up in Big Picture Mode?" "Find the webpack module that defines the DialogButton component." "Make the Quick Access Menu background darker." "Something is throwing a React error on the downloads page — find it."

SKILL.md is a strict SOP rather than a tutorial: it gates work behind a preflight check, fixes which commands may be used, and defines how to verify a result before reporting it — because the easiest mistake here is a confident answer drawn from the wrong window, a stale route, or a style that computed but never painted.


Requirements

  • Node.js 22+ — uses built-in WebSocket and fetch, no dependencies
  • A Steam client with CDP enabled — either:
    • desktop, launched with -cef-enable-debugging (see below), or
    • a Steam Deck with Settings → System → Developer → CEF Remote Debugging, reachable on your network. Address it with --host; SteamOS serves CDP on port 8081.
  • Chrome — optional, only for the interactive DevTools UI

Launch Steam in debug mode

Launch flags are read only at startup. A already-running instance silently ignores them, so it must be closed first — note that this drops in-progress downloads and running games.

# macOS
pkill -f Steam
# Linux
pkill steam
# Windows
taskkill /IM steam.exe /F
PlatformCommand
macOSopen -a Steam --args -dev -windowed -cef-enable-debugging -gamepadui
Linuxsteam -dev -windowed -cef-enable-debugging -gamepadui
Windowssteam.exe -dev -windowed -cef-enable-debugging -gamepadui
Steam DeckSettings → System → Developer → CEF Remote Debugging
FlagEffect
-cef-enable-debuggingRequired. Opens CDP on port 8080 (8081 on Steam Deck)
-devDeveloper mode — relaxed security, verbose logging
-windowedRun windowed instead of fullscreen
-gamepaduiBig Picture Mode. Required for page, menu, and stores

Omit -gamepadui to debug the classic desktop UI, which is a different front end.

curl http://localhost:8080/json/version   # {"Browser": "Chrome/...", ...}

Steam takes 30–90 seconds to fully initialise. Poll status until both marks are ✓.


Usage

S=~/.claude/skills/steam-debug/steam-debug.mjs

node $S status
node $S help
CommandDescription
statusCDP endpoint, target count, webpack module count, init state
doctorDiagnose the whole setup and print the remedy for whatever is wrong
targetsAll CDP targets with title, URL, WebSocket URL
eval <expr>Evaluate JS; promises awaited; objects returned as JSON
errorsInstall a console.error capture shim, print what it caught
logsStream live console, browser and Steam-backend output until Ctrl+C
console <cmd> / console listRun a Steam developer-console command, or list what exists
restart <js|client>Restart the UI or the whole client, and wait for it to come back
reactReact version, module ID, fiber tree stats
styles <selector>Computed styles, layout rect, resolved CSS custom properties
dom <selector>Dump an element subtree — structure, sizes, leaf text
text [selector]Dump the visible on-screen text — cheap alternative to a screenshot
webpack <pattern>Search every webpack module's source
classes <pattern>Resolve minified CSS-module class names by readable name
module <id>Dump a webpack module's full source
navigate <page>Drive Big Picture Mode to a page
pageCurrent route and open menu
menu <name>Open or close Quick Access / Main Menu
popupsPopup windows tracked by g_PopupManager
storeswindow.SteamUIStore sub-stores and properties
screenshot [selector]Capture what is actually painted, as a PNG
inject css|js <file>Inject a stylesheet or script, namespaced and reversible
inject list / inject remove <slug>List or undo injections
watch css|js <file>Re-inject on every file change until Ctrl+C
OptionApplies toDefault
--target <name>eval, errors, logs, styles, dom, text, module, screenshot, inject, watchSharedJSContext
--port <n>alltries 8080, 8081, then 9222
--host <addr>alllocalhost — comma-separate for several devices
--timeout <ms>all10000
--jsonalloff
--level <all|warn|error>logsall
--source <all|console|browser|backend>logsall
--grep <regex>logs—
--limit <n>webpack, classes, console list, text10 / 20 / 500
--ignore-casewebpack, classes, console listoff
--depth <n>dom2
--out <path>screenshotderived from target title
--diff <path>screenshot—
--settlescreenshotoff
--file <path>eval—
--id <slug>inject, watchderived from filename
--confirmrestart, consoleoff
--show-secretsalloff

--json works on every command and guarantees machine-readable stdout, so nothing has to be parsed out of prose. logs --json emits one JSON object per line.

Credentials are redacted by default. Any JSON value under a key that looks like a token, password, Steam Guard blob, machine ID or session id is replaced with a description of what was withheld, and eval refuses an expression touching SteamClient.Auth. Pass --show-secrets when you are deliberately debugging sign-in.

--host takes a list, so any command can run against a desktop client and a Steam Deck together — the practical way to check a plugin behaves the same on both:

node $S page --host localhost,steamdeck
node $S inject css theme.css --host localhost,steamdeck --target BigPicture
node $S logs --host localhost,steamdeck --level error   # concurrent, tagged per device

Output is labelled per device, --json aggregates into { devices: [...] }, --out is suffixed so captures do not overwrite, and the exit code is 0 only if every device succeeded.


Reading Steam's own logs

Three streams, not o

// HOW IT'S BUILT

// FILES

78 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • SKILL.md36 KB70831f4a4d9ctruncatedupstream ↗

    Showing the inlined prefix. The rest is in the upstream file.

    ---
    name: steam-debug
    description: Inspect, debug, and inject custom code into a running Steam client — desktop (macOS, Linux, Windows) or Steam Deck over the network — through its Chromium Embedded Framework (CEF) Chrome DevTools Protocol endpoint. Use when developing Steam UI plugins, mods, themes, or integrations — injecting CSS/JS to try a change, locating webpack modules and obfuscated class names, reading React or SteamUIStore state, inspecting Big Picture / Quick Access Menu windows, screenshotting what actually rendered, streaming console logs, or diagnosing runtime errors in Steam's UI. The same commands run against either device, or both at once. Injection is per-session and for development only. Not for building a plugin loader or making changes persist across restarts, Steamworks game SDK work, game development, or scraping the public Steam web store.
    ---
    
    # Steam Client — Runtime Debug & Injection SOP
    
    Steam's UI is a Chromium (CEF) app. Launched with debug flags it exposes a Chrome DevTools
    Protocol endpoint, so the whole UI can be inspected and modified at runtime the way a web page
    can. `steam-debug.mjs` wraps that protocol as a CLI.
    
    Works against a **desktop client** (macOS, Linux, Windows) and a **Steam Deck** over the network —
    the same commands, selected with `--host`. Both are verified by the test suite.
    
    This document is an operating procedure, not a tutorial. Follow the phases in order.
    Section 1 rules are binding; Section 2 defaults may be overridden with a stated reason.
    
    **Scope.** This skill inspects and debugs a running Steam client — desktop or Steam Deck — and
    lets you try changes against it. Injection is per-session and disappears on reload; that is
    deliberate.
    
    Out of scope, and not to be improvised: making a change persist or load on startup, packaging or
    distributing plugins, and anything that runs unattended inside someone's client. That is a plugin
    loader's job. If a request needs it, say so and stop.
    
    The boundary is simple — this skill helps you *find out what is going on* and *try a change*.
    Making a change stick is someone else's job.
    
    **Requires Node.js 22+.** Chrome is optional (only for the interactive DevTools UI).
    
    ---
    
    ## 0. Session setup
    
    Run once per session, before anything else:
    
    ```bash
    S=~/.claude/skills/steam-debug/steam-debug.mjs
    # Windows PowerShell: $S = "$env:USERPROFILE\.claude\skills\steam-debug\steam-debug.mjs"
    ```
    
    Every command in this document assumes `$S` is set. Never hardcode a different path.
    
    ### 0.1 Required inputs — establish before Phase 1
    
    Four facts change which commands are valid. Establish each from the user's request, or from a
    command, before acting. **Never assume a default silently**: if a fact is unstated and the
    listed fallback is wrong, the answer is wrong in a way that still looks right.
    
    | # | Input | How to establish it | Fallback if unstated |
    |---|---|---|---|
    | I1 | **Device** — desktop, a Deck, or both | The user names it, or `--host` is given | `localhost` (desktop, port 8080). A Deck is never assumed. |
    | I2 | **UI mode** — Big Picture (`-gamepadui`) or classic desktop | `status`, then `page` (exit 1 ⇒ no Big Picture window) | Whatever is running. Never relaunch to change mode without consent (R9). |
    | I3 | **Target window** | `targets`, then §5 of `reference/targets.md` | `SharedJSContext` (§2) |
    | I4 | **Task class** — inspect (read-only) or inject (mutates the client) | The user's verb | inspect. Never escalate to inject on your own initiative. |
    
    Ask the user only when a fallback would be actively misleading — a Deck-specific question with
    no `--host`, or an inject request that does not say which window. Otherwise state the assumption
    in Phase 1 and proceed.
    
    ---
    
    ## 1. Hard rules — MUST
    
    Violating any of these produces an answer that is wrong even if it looks right.
    
    **R1 — Preflight gate.** Do not run any inspect, navigate, or inject command until, in this
    session, **either** `doctor` exited 0, **or** `status` reported `Webpack bundle: ✓` **and**
    `Steam init done: ✓`. Anything else → Failure Ladder (§6). Never skip this because Steam "looks"
    open, and never carry a preflight result over from an earlier session.
    
    **R2 — Closed command surface.** Only the commands and flags listed in §4 exist. Never invent a
    command, flag, subcommand, or alias, and never infer one from a pattern. If a task needs
    something outside that surface, say so explicitly and fall back to `eval`.
    
    **R3 — Target discipline.** `--target` is accepted only by `eval`, `errors`, `logs`, `styles`,
    `dom`, `text`, `module`, `screenshot`, `inject`, and `watch`. Every other command always runs
    against the shared JS context and rejects `--target` outright. Never state or imply that a result
    came from a window the command cannot reach.
    
    **R4 — Read the exit code *and* the payload.** 0 means the data you asked for was produced; 1
    means the command failed or found nothing; 2 means the invocation was wrong. An empty result is
    exit 1, so "no matches" never reads as success. Commands returning JSON also print
    `{"error": "..."}` on stdout when they fail.
    
    **R5 — Verify state changes.** `navigate` and `menu` both verify themselves: each polls the
    state it changed and exits 1 if it did not move, so a no-op cannot be mistaken for success —
    trust their exit code and do not re-confirm with `page`. Nothing else self-verifies. Every other
    mutation — injection, `console`, `eval` with a side effect — needs the independent check named in
    Phase 4 before you report it worked.
    
    **R6 — Never fabricate build-specific identifiers.** Webpack module IDs, obfuscated CSS class
    names, React version, and module counts change with every Steam build. Every such value you
    report must come from a command you ran in this session. Never reuse one from memory, from this
    document's examples, or from a previous session.
    
    **R7 — Confirm visibility before inspecting the DOM.** Elements exist only while their feature is
    rendered and only inside the window that owns them. Before any DOM or CSS conclusion, confirm
    the route with `page` and confirm you are querying the correct target (§5 of
    `reference/targets.md`).
    
    **R8 — Injection hygiene.** Use the `inject` command, which namespaces, registers, and makes the
    change reversible for you. Do not hand-roll injection through `eval` unless `inject` cannot
    express it, and if you do, match its contract: a `steam-debug-<slug>` id and remove-then-add.
    Always give the user the removal command, and never describe an injection as persistent — every
    one is lost on reload or restart.
    
    **R9 — Never restart, crash, or kill Steam without explicit user confirmation.** A restart drops
    in-progress downloads, running games, and Remote Play sessions. Ask, then use `restart`, which
    requires `--confirm` and refuses while a game or download is active — never `pkill`. Prefer
    `restart js`, which reloads only the UI; escalate to `restart client` only when the client itself
    is gone or wedged. Relaunching is the last rung of the Failure Ladder, not a first response.
    
    The same consent applies to `console` commands that take the client down — `minidump_crash` and
    `minidump_assert` deliberately crash or assert Steam, and the CLI refuses them (exit 2) without
    `--confirm`. Never pass `--confirm` to either on your own initiative. Treat any console command
    you cannot describe the effect of as destructive until `console list` says otherwise.
    
    **R10 — Report observed values verbatim.** Quote real IDs, counts, selectors, and versions from
    command output. Do not round, paraphrase, or reconstruct them from memory. The one exception is
    R12: credentials and personal data are redacted, never quoted.
    
    **R11 — "Nothing happened" is not a diagnosis until the backend has been read.** A `SteamClient`
    call with wrong arguments, or one the client refuses, returns cleanly to JavaScript and fails
    silently in Steam's backend. Before reporting that code ran without effect, check
    `logs --source backend` (or the `backendErrors` field `inject`
  • README.md20 KBb18aa2f195e6upstream ↗
    # steam-debug
    
    A **Claude skill** and standalone CLI for inspecting, debugging, and injecting code into a
    running **Steam client** — desktop or Steam Deck — via the Chrome DevTools Protocol (CDP).
    
    Steam's UI is a Chromium Embedded Framework (CEF) app. Launched with debug flags it exposes the
    same protocol browser DevTools uses, so the entire Steam UI can be inspected and modified at
    runtime like a web page. `steam-debug.mjs` wraps that protocol into focused commands — read React
    state, search webpack modules, resolve minified class names, inspect computed CSS, drive
    navigation, stream logs, and inject custom CSS/JS.
    
    Built for plugin, theme, and integration development against Steam's UI.
    
    **Works on desktop and Steam Deck.** Same commands for both — a desktop client on macOS, Linux or
    Windows, and a Deck over the network via `--host`. Both are exercised by the test suite, and any
    command can run against both at once. See [reference/remote.md](reference/remote.md).
    
    **Scope.** This is a debugging and development tool. Injection is per-session and disappears on
    reload, by design — it exists so you can try a change and see what happens.
    
    Out of scope: making a change persist or load on startup, packaging or distributing plugins, and
    anything that runs unattended inside someone's client. That belongs in a plugin loader. The
    boundary is simple — this helps you find out what is going on and try a change; making a change
    stick is someone else's job.
    
    ---
    
    ## Using with Claude
    
    Place this directory at `~/.claude/skills/steam-debug/`. Claude Code discovers it via `SKILL.md`.
    
    Describe the task in plain language; Claude selects the commands, interprets output, and follows
    the operating procedure in `SKILL.md`:
    
    > *"Why is my injected CSS not showing up in Big Picture Mode?"*
    > *"Find the webpack module that defines the DialogButton component."*
    > *"Make the Quick Access Menu background darker."*
    > *"Something is throwing a React error on the downloads page — find it."*
    
    `SKILL.md` is a strict SOP rather than a tutorial: it gates work behind a preflight check, fixes
    which commands may be used, and defines how to verify a result before reporting it — because the
    easiest mistake here is a confident answer drawn from the wrong window, a stale route, or a style
    that computed but never painted.
    
    ---
    
    ## Requirements
    
    - **Node.js 22+** — uses built-in `WebSocket` and `fetch`, no dependencies
    - **A Steam client with CDP enabled** — either:
      - desktop, launched with `-cef-enable-debugging` (see below), or
      - a Steam Deck with Settings → System → Developer → **CEF Remote Debugging**, reachable on
        your network. Address it with `--host`; SteamOS serves CDP on port 8081.
    - **Chrome** — optional, only for the interactive DevTools UI
    
    ---
    
    ## Launch Steam in debug mode
    
    Launch flags are read **only at startup**. A already-running instance silently ignores them, so
    it must be closed first — note that this drops in-progress downloads and running games.
    
    ```bash
    # macOS
    pkill -f Steam
    # Linux
    pkill steam
    # Windows
    taskkill /IM steam.exe /F
    ```
    
    | Platform | Command |
    |---|---|
    | macOS | `open -a Steam --args -dev -windowed -cef-enable-debugging -gamepadui` |
    | Linux | `steam -dev -windowed -cef-enable-debugging -gamepadui` |
    | Windows | `steam.exe -dev -windowed -cef-enable-debugging -gamepadui` |
    | Steam Deck | Settings → System → Developer → CEF Remote Debugging |
    
    | Flag | Effect |
    |---|---|
    | `-cef-enable-debugging` | **Required.** Opens CDP on port 8080 (8081 on Steam Deck) |
    | `-dev` | Developer mode — relaxed security, verbose logging |
    | `-windowed` | Run windowed instead of fullscreen |
    | `-gamepadui` | Big Picture Mode. Required for `page`, `menu`, and `stores` |
    
    Omit `-gamepadui` to debug the classic desktop UI, which is a different front end.
    
    ```bash
    curl http://localhost:8080/json/version   # {"Browser": "Chrome/...", ...}
    ```
    
    Steam takes 30–90 seconds to fully initialise. Poll `status` until both marks are `✓`.
    
    ---
    
    ## Usage
    
    ```bash
    S=~/.claude/skills/steam-debug/steam-debug.mjs
    
    node $S status
    node $S help
    ```
    
    | Command | Description |
    |---|---|
    | `status` | CDP endpoint, target count, webpack module count, init state |
    | `doctor` | Diagnose the whole setup and print the remedy for whatever is wrong |
    | `targets` | All CDP targets with title, URL, WebSocket URL |
    | `eval <expr>` | Evaluate JS; promises awaited; objects returned as JSON |
    | `errors` | Install a `console.error` capture shim, print what it caught |
    | `logs` | Stream live console, browser and Steam-backend output until Ctrl+C |
    | `console <cmd>` / `console list` | Run a Steam developer-console command, or list what exists |
    | `restart <js\|client>` | Restart the UI or the whole client, and wait for it to come back |
    | `react` | React version, module ID, fiber tree stats |
    | `styles <selector>` | Computed styles, layout rect, resolved CSS custom properties |
    | `dom <selector>` | Dump an element subtree — structure, sizes, leaf text |
    | `text [selector]` | Dump the visible on-screen text — cheap alternative to a screenshot |
    | `webpack <pattern>` | Search every webpack module's source |
    | `classes <pattern>` | Resolve minified CSS-module class names by readable name |
    | `module <id>` | Dump a webpack module's full source |
    | `navigate <page>` | Drive Big Picture Mode to a page |
    | `page` | Current route and open menu |
    | `menu <name>` | Open or close Quick Access / Main Menu |
    | `popups` | Popup windows tracked by `g_PopupManager` |
    | `stores` | `window.SteamUIStore` sub-stores and properties |
    | `screenshot [selector]` | Capture what is actually painted, as a PNG |
    | `inject css\|js <file>` | Inject a stylesheet or script, namespaced and reversible |
    | `inject list` / `inject remove <slug>` | List or undo injections |
    | `watch css\|js <file>` | Re-inject on every file change until Ctrl+C |
    
    | Option | Applies to | Default |
    |---|---|---|
    | `--target <name>` | `eval`, `errors`, `logs`, `styles`, `dom`, `text`, `module`, `screenshot`, `inject`, `watch` | `SharedJSContext` |
    | `--port <n>` | all | tries 8080, 8081, then 9222 |
    | `--host <addr>` | all | `localhost` — comma-separate for several devices |
    | `--timeout <ms>` | all | `10000` |
    | `--json` | all | off |
    | `--level <all\|warn\|error>` | `logs` | `all` |
    | `--source <all\|console\|browser\|backend>` | `logs` | `all` |
    | `--grep <regex>` | `logs` | — |
    | `--limit <n>` | `webpack`, `classes`, `console list`, `text` | `10` / `20` / `500` |
    | `--ignore-case` | `webpack`, `classes`, `console list` | off |
    | `--depth <n>` | `dom` | `2` |
    | `--out <path>` | `screenshot` | derived from target title |
    | `--diff <path>` | `screenshot` | — |
    | `--settle` | `screenshot` | off |
    | `--file <path>` | `eval` | — |
    | `--id <slug>` | `inject`, `watch` | derived from filename |
    | `--confirm` | `restart`, `console` | off |
    | `--show-secrets` | all | off |
    
    **`--json` works on every command** and guarantees machine-readable stdout, so nothing has to be
    parsed out of prose. `logs --json` emits one JSON object per line.
    
    **Credentials are redacted by default.** Any JSON value under a key that looks like a token,
    password, Steam Guard blob, machine ID or session id is replaced with a description of what was
    withheld, and `eval` refuses an expression touching `SteamClient.Auth`. Pass `--show-secrets`
    when you are deliberately debugging sign-in.
    
    **`--host` takes a list**, so any command can run against a desktop client and a Steam Deck
    together — the practical way to check a plugin behaves the same on both:
    
    ```bash
    node $S page --host localhost,steamdeck
    node $S inject css theme.css --host localhost,steamdeck --target BigPicture
    node $S logs --host localhost,steamdeck --level error   # concurrent, tagged per device
    ```
    
    Output is labelled per device, `--json` aggregates into `{ devices: [...] }`, `--out` is suffixed
    so captures do not overwrite, and the exit code is 0 only if every device succeeded.
    
    ---
    
    ## Reading Steam's own logs
    
    Three streams, not one. `logs` reads all of them and tags each line with where it came from:
    
    ```text
    [ERROR] Uncaught TypeError: …                  console — page JavaScript
    [ERROR] (theme.css) Failed to load resource    browser — CEF
    [ERROR] (backend) RaiseJSException: …          backend — Steam itself
    ```
    
    The backend stream is Steam's own output — the same thing a terminal launch shows with `-dev` —
    delivered over CDP through `SteamClient.Console`. **No terminal launch, no SSH, nothing installed,
    and it works the same on a Steam Deck over `--host`.**
    
    It matters because it is the only stream that names the Steam component behind a failure. A
    `SteamClient` call made with the wrong arguments returns cleanly to JavaScript and is refused in
    the backend, so without it the symptom is "my code ran and nothing happened":
    
    ```bash
    node $S logs --source backend --level error
    node $S console list 'log|dump'    # what this build's dev console offers
    node $S console app_status 570     # ask the client directly
    ```
    
    `inject` watches the same stream while it applies your file and reports what it heard in
    `backendErrors`.
    
    ## Recovering from a crash
    
    Injecting into a live client sometimes takes it down. `logs` and `watch` exit 1 when the CDP
    connection drops, and `watch` prints the backend lines it captured first — after a crash that tail
    is the only copy left.
    
    ```bash
    node $S status                     # exit 1 → the client is gone
    node $S restart client --confirm   # relaunches with debugging enabled, waits for ready
    node $S inject js plugin.js        # re-apply; nothing survived
    ```
    
    `restart js --confirm` is the cheaper step when only the UI is wedged — about a second, and CDP
    survives. Both refuse while a game is running, and `restart client` also refuses during a
    download.
    
    `restart client` shuts Steam down and launches it again itself rather than calling
    `SteamClient.User.StartRestart()`, because Steam's own restart drops `-cef-enable-debugging` and
    the client would come back unreachable.
    
    Full semantics in [reference/commands.md](reference/commands.md).
    
    ---
    
    ## Targets
    
    Steam runs several CEF renderers. Each is a separate CDP target — effectively separate browser
    tabs that cannot see each other's JavaScript.
    
    | Name | webpack | `SteamUIStore` | Use for |
    |---|---|---|---|
    | `SharedJSContext` | **yes** | **yes** | All JS, webpack, React, stores — start here |
    | `BigPicture` | no | no | Big Picture DOM and CSS |
    | `QuickAccess` | no | no | Quick Access Menu DOM and CSS |
    | `MainMenu` | no | no | Main Menu DOM and CSS |
    | `NotificationToasts` | no | no | Toast DOM and CSS |
    
    **Only `SharedJSContext` has webpack and `SteamUIStore`** — the others return `undefined` for
    both, so run logic there and use the rest for DOM/CSS only. A `Store` alias also exists but
    resolves only while a store window is open.
    
    The popup windows are loaded from startup and persist for the whole session, so their DOM can be
    inspected without opening them. Their *layout*, though, may not exist until the menu has been
    shown once — measured directly on a Steam Deck. `NotificationToasts` is created lazily and may
    not exist yet on either platform. On a Deck the viewport is 854×534 at 1.5× rather than 1280×800
    at 2×. Details in
    [reference/targets.md](reference/targets.md) and [reference/remote.md](reference/remote.md).
    
    ---
    
    ## Exit codes
    
    | Code | Meaning |
    |---|---|
    | `0` | The requested data was produced |
    | `1` | Failed, or found nothing — not found, no matches, no route change |
    | `2` | Wrong invocation — unknown command, missing argument, invalid flag value |
    
    An empty result is exit 1, so "searched and found nothing" never reads as success. Commands
    returning JSON still print `{"error": …}` on stdout when they fail, so the payload stays
    parseable alongside the status code.
    
    Invalid input is rejected rather than ignored — a flag the command does not act on, an
    unrecognised `--level`, a non-numeric `--limit`, or a flag with no value all exit 2 with an
    explanatory message. `navigate` and `menu` both verify their own result and exit 1 if the state
    did not actually change, so a no-op cannot be mistaken for success.
    
    ## Verifying a visual change
    
    **A computed style is not proof of a visible change.** CEF drops some paints entirely, so
    `styles` can report exactly the value you asked for while the screen is unchanged. `screenshot`
    captures what the compositor actually drew, and `--diff` turns "nothing happened" into an exit
    code:
    
    ```bash
    node $S screenshot --target BigPicture --out before.png --settle
    node $S inject css theme.css --target BigPicture
    node $S screenshot --target BigPicture --out after.png --settle --diff before.png
    # Changed: 20312 of 4096000 px (0.4959%), bounding box 265x104 at 66,732
    ```
    
    `--diff` exits 1 when the images are identical. The bounding box localises the change, which is a
    fast way to confirm you affected the element you meant to.
    
    Pass `--settle` on both captures. Big Picture keeps repainting for seconds after a route change —
    it loads hero artwork progressively — so an unsettled baseline registers that animation as your
    change.
    
    The usual cause of an invisible change is Steam's `.BasicUI` layer — an opaque, full-viewport
    element that covers anything painted on `body` or any ancestor above it. Style the leaf element
    that owns the pixels instead. Details in [reference/injection.md](reference/injection.md).
    
    `screenshot` cannot capture `QuickAccess`, `MainMenu`, or `NotificationToasts` — they are
    composited outside the page tree and CDP capture hangs on them.
    
    The usual cause is Steam's `.BasicUI` layer covering anything painted on `body` — style the leaf
    element that owns the pixels instead.
    
    ---
    
    ## Reading what's on screen, without a screenshot
    
    `screenshot` answers "did the pixels change"; `text` answers "what does it say" — for a fraction
    of the cost. It walks the DOM instead of capturing and decoding an image, so there is no PNG to
    encode, no vision-model pass, and no risk of a misread character: every string it returns came
    straight out of an HTML text node that is actually laid out on screen.
    
    ```bash
    node $S text                                    # everything visible under <body>
    node $S text ".gamelist" --limit 100            # scope to one container
    node $S text --target BigPicture --json         # machine-readable, with the target field
    ```
    
    Visibility is judged by layout (a zero-size or `display: none`/`visibility: hidden` element
    contributes nothing), not by OCR confidence, so a hidden tooltip or an off-screen menu never shows
    up as "on screen" the way a screenshot crop might mislead you into believing. Each element's own
    direct text is reported once, not once per ancestor, so a page with deeply nested wrappers does
    not repeat itself.
    
    Reach for `screenshot` instead when the question is about layout, color, or something drawn to a
    `<canvas>`/WebGL surface — `text` only sees real DOM text nodes.
    
    ---
    
    ## Injecting code
    
    Write the CSS or JS to a file and let `inject` handle namespacing and reversal:
    
    ```bash
    node $S inject css theme.css --target BigPicture    # id defaults to the filename: "theme"
    node $S inject list          --target BigPicture
    node $S inject remove theme  --target BigPicture
    ```
    
    Every artifact gets a `steam-debug-<slug>` id and is registered so it can be listed and undone.
    Injection is remove-then-add, so re-running never accumulates duplicates. A JS file should
    `return` a teardown function — `inject` stores it and calls it on removal.
    
    While iterating, `watch` re-injects on every save until you stop it:
    
    ```bash
    node $S watch css theme.css --target BigPicture
    ```
    
    Injections live in page memory and are **lost on reload or restart**.
    
    Steam's class names are minified per build and must be re-resolved every time — use `classes` to
    look one up rather than reusing it from notes. Full playbook in
    [reference/injection.md](reference/injection.md).
    
    ---
    
    ## Documentation
    
    | File | Contents |
    |---|---|
    | [SKILL.md](SKILL.md) | Operating procedure — guardrails, phases, command contract |
    | [reference/commands.md](reference/commands.md) | Per-command semantics and output shapes |
    | [reference/targets.md](reference/targets.md) | Windows, popups, routes, navigation |
    | [reference/injection.md](reference/injection.md) | CSS/JS injection, CEF paint traps, plugin patterns |
    | [reference/troubleshooting.md](reference/troubleshooting.md) | Log streams, error tables, React decoding, crash recovery |
    | [reference/steam-client-api.md](reference/steam-client-api.md) | Calling a `SteamClient` API the CLI does not wrap |
    | [reference/remote.md](reference/remote.md) | Steam Deck / SteamOS — verified on hardware |
    | [reference/launch-options.md](reference/launch-options.md) | Full Steam command-line reference — optional, rarely needed |
    | [docs/steam-client/](docs/steam-client/) | TypeScript definitions for the whole `SteamClient` surface |
    
    ---
    
    ## Testing
    
    ```bash
    node --test test/skill-lint.mjs            # offline: docs vs implementation
    node --test test/smoke.mjs                 # live, desktop
    node test/run-devices.mjs desktop deck     # live, both devices in sequence
    ```
    
    `skill-lint.mjs` needs neither Steam nor a network. It fails when documentation drifts from code —
    a command or flag named in the docs that does not exist, a stale `--target` column in `SKILL.md`,
    an implemented command that is undocumented, `help` or this README missing a command, or a broken
    reference link.
    
    `smoke.mjs` exercises the whole command surface against a real client: reachability, `eval`,
    `navigate`/`page` and `menu`/`page` round-trips, every named target alias, `screenshot` with
    `--diff` and `--settle`, the full `inject` lifecycle including teardown, `watch` hot-reload,
    `doctor`, `dom`, `classes`, log filtering, and the usage/failure exit codes.
    
    It also covers the debug loop end to end: `console` against Steam's own command table, backend
    spew arriving over `logs --source backend`, `inject` reporting a deliberately-refused
    `SteamClient` call, every `restart` guardrail, and — on desktop only — an actual `restart js` that
    must replace the JS context and come back ready.
    
    ### Choosing the device
    
    | | Desktop | Steam Deck |
    |---|---|---|
    | Select with | *(default)* | `STEAM_DEBUG_DEVICE=deck` |
    | Connection | localhost, default ports | `STEAM_DECK_HOST` (default `steamdeck`) port 8081 |
    | Steam auto-launched | yes | **never** |
    
    Every command in the suite gets the device's `--host`/`--port` automatically, so the same tests
    validate both. The only device-aware case is `restart js`, which is skipped anywhere the suite is
    not allowed to launch Steam — it must never restart someone else's device.
    
    ```bash
    STEAM_DEBUG_DEVICE=deck node --test test/smoke.mjs
    STEAM_DECK_HOST=192.168.1.42 node test/run-devices.mjs deck
    ```
    
    On desktop, Steam is launched with debug flags if it is not already running; if it is running
    *without* `-cef-enable-debugging`, kill it first (`pkill -f steam_osx` on macOS, `pkill steam` on
    Linux).
    
    A Deck is **never** launched or restarted by the suite — enable
    Settings → System → Developer → CEF Remote Debugging first. Note the suite navigates, opens menus
    and injects CSS, so expect to see it working on the device. It cleans up after itself.
    
    ---
    
    ## How it works
    
    Steam's CEF runtime exposes a CDP WebSocket on port 8080, or 8081 on a Steam Deck. `steam-debug.mjs` connects, issues
    `Runtime.evaluate` and related commands, and formats the results — the same protocol Chrome
    DevTools speaks. Node 22+ built-ins only.
    
    Globals available in `SharedJSContext`:
    
    ```js
    window.webpackChunksteamui          // webpack chunk array — presence means the bundle loaded
    window.App?.BFinishedInitBeforeLogin() // true once Steam has finished initialising
    window.SteamUIStore                 // MobX state: navigation, menus, windows
    window.SteamClient                  // native client API bridge
    window.g_PopupManager               // popup window registry
    window.__steam_debug_wr             // cached webpack require — set by this tool
    ```
    
    `window.React` does not exist; React lives inside the bundle. Use `react` to find its module ID.
    
    The tool leaves `window.__steam_debug_wr` behind on most commands, and `errors` permanently wraps
    `console.error`. Both clear on reload.
    
    ---
    
    ## License
    
    [CC0 1.0 Universal](LICENSE) — public domain dedication.
    
  • .gitattributes66 Bdfe0770424b2upstream ↗
    # Auto detect text files and perform LF normalization
    * text=auto
    
  • .gitignore2.1 KBb6194ac02be7upstream ↗
    # Logs
    logs
    *.log
    npm-debug.log*
    yarn-debug.log*
    yarn-error.log*
    lerna-debug.log*
    .pnpm-debug.log*
    
    # Diagnostic reports (https://nodejs.org/api/report.html)
    report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
    
    # Runtime data
    pids
    *.pid
    *.seed
    *.pid.lock
    
    # Directory for instrumented libs generated by jscoverage/JSCover
    lib-cov
    
    # Coverage directory used by tools like istanbul
    coverage
    *.lcov
    
    # nyc test coverage
    .nyc_output
    
    # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
    .grunt
    
    # Bower dependency directory (https://bower.io/)
    bower_components
    
    # node-waf configuration
    .lock-wscript
    
    # Compiled binary addons (https://nodejs.org/api/addons.html)
    build/Release
    
    # Dependency directories
    node_modules/
    jspm_packages/
    
    # Snowpack dependency directory (https://snowpack.dev/)
    web_modules/
    
    # TypeScript cache
    *.tsbuildinfo
    
    # Optional npm cache directory
    .npm
    
    # Optional eslint cache
    .eslintcache
    
    # Optional stylelint cache
    .stylelintcache
    
    # Microbundle cache
    .rpt2_cache/
    .rts2_cache_cjs/
    .rts2_cache_es/
    .rts2_cache_umd/
    
    # Optional REPL history
    .node_repl_history
    
    # Output of 'npm pack'
    *.tgz
    
    # Yarn Integrity file
    .yarn-integrity
    
    # dotenv environment variable files
    .env
    .env.development.local
    .env.test.local
    .env.production.local
    .env.local
    
    # parcel-bundler cache (https://parceljs.org/)
    .cache
    .parcel-cache
    
    # Next.js build output
    .next
    out
    
    # Nuxt.js build / generate output
    .nuxt
    dist
    
    # Gatsby files
    .cache/
    # Comment in the public line in if your project uses Gatsby and not Next.js
    # https://nextjs.org/blog/next-9-1#public-directory-support
    # public
    
    # vuepress build output
    .vuepress/dist
    
    # vuepress v2.x temp and cache directory
    .temp
    .cache
    
    # vitepress build output
    **/.vitepress/dist
    
    # vitepress cache directory
    **/.vitepress/cache
    
    # Docusaurus cache and generated files
    .docusaurus
    
    # Serverless directories
    .serverless/
    
    # FuseBox cache
    .fusebox/
    
    # DynamoDB Local files
    .dynamodb/
    
    # TernJS port file
    .tern-port
    
    # Stores VSCode versions used for testing VSCode extensions
    .vscode-test
    
    # yarn v2
    .yarn/cache
    .yarn/unplugged
    .yarn/build-state.yml
    .yarn/install-state.gz
    .pnp.*
    
    # macOS
    .DS_Store
    
  • .prettierrc.json41 Be9e3a01c3106upstream ↗
    {
      "tabWidth": 4,
      "printWidth": 120
    }
    
  • docs/steam-client/Apps.ts53 KB444014bcdec7upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/Auth.ts2.4 KBd1595e56225fupstream ↗
    import { EResult, JsPbMessage, OperationResponse } from "./shared";
    import { EOSType } from "./System";
    
    export interface Auth {
        /**
         * @returns a boolean indicating if the operation succeeded.
         */
        ClearCachedSignInPin(): Promise<boolean>;
    
        CurrentUserHasCachedSignInPin(): Promise<boolean>;
    
        GetLocalHostname(): Promise<string>;
    
        /**
         * @returns a ProtoBuf message. If deserialized, returns {@link CAuthentication_DeviceDetails}.
         */
        GetMachineID(): Promise<ArrayBuffer>;
    
        GetRefreshInfo(): Promise<AuthRefreshInfo>;
    
        GetSteamGuardData(param0: string): Promise<SteamGuardData>;
    
        /**
         * "Secured" refers to unshared.
         */
        IsSecureComputer(): Promise<boolean>;
    
        SetCachedSignInPin(pin: string): Promise<boolean>;
    
        SetLoginToken(refreshToken: string, accountName: string): Promise<OperationResponse>;
    
        SetSteamGuardData(accountName: string, newGuardData: string): void;
    
        StartSignInFromCache(accountName: string, offlineMode: boolean): Promise<OperationResponse | void>;
    
        UserHasCachedSignInPin(accountName: string): Promise<boolean>;
    
        ValidateCachedSignInPin(accountName: string, pin: string): Promise<boolean>;
    }
    
    export interface AuthRefreshInfo {
        reason: number;
        account_name: string;
        login_id_token: string;
    }
    
    export interface SteamGuardData {
        data: string;
        eresult: EResult;
    }
    
    /**
     * `deserializeBinary` argument:
     * ```
     * [
     *     await SteamClient.System.GetOSType(),
     *     await SteamClient.Auth.GetLocalHostname(),
     *     await SteamClient.Auth.GetMachineID(),
     * ];
     * ```
     */
    export interface CAuthentication_DeviceDetails extends JsPbMessage {
        client_count(): number | undefined;
    
        device_friendly_name(): string | undefined;
    
        gaming_device_type(): EGamingDeviceType | undefined;
    
        machine_id(): Uint8Array | string;
    
        os_type(): EOSType | undefined;
    
        platform_type(): EAuthTokenPlatformType | undefined;
    
        set_client_count(): any;
    
        set_device_friendly_name(): any;
    
        set_gaming_device_type(): any;
    
        set_machine_id(): any;
    
        set_os_type(): any;
    
        set_platform_type(): any;
    }
    
    export enum EAuthTokenPlatformType {
        Unknown,
        SteamClient,
        WebBrowser,
        MobileApp,
    }
    
    export enum EGamingDeviceType {
        Unknown,
        StandardPC,
        Console = 256,
        PS3 = 272,
        Steambox = 288,
        Tesla = 320,
        Handheld = 512,
        Phone = 528,
        SteamDeck = 544,
    }
    
  • docs/steam-client/Broadcast.ts1.8 KBb3eec561b30dupstream ↗
    import { EResult, Unregisterable } from "./shared";
    
    export interface Broadcast {
        /**
         * Approves a viewer request for the broadcast.
         * @param steamId64 The SteamID64 of the user whose request is to be approved.
         */
        ApproveViewerRequest(steamId64: string, param1: number): void;
    
        /**
         * Invites a user identified by their SteamID64 to watch the broadcast.
         * @param steamId64 The SteamID64 of the user to invite.
         */
        InviteToWatch(steamId64: string): Promise<EResult>;
    
        /**
         * Registers a callback to be called when the broadcast status changes.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForBroadcastStatus(callback: (status: BroadcastStatus) => void): Unregisterable;
    
        /**
         * Registers a callback to be called when viewer requests are received.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForViewerRequests(
            callback: (viewerFriendCode: number, param1: number, param2: number) => void,
        ): Unregisterable;
    
        /**
         * Rejects a viewer request for the broadcast.
         * @param steamId64 The SteamID64 of the user whose request is to be rejected.
         */
        RejectViewerRequest(steamId64: string, param1: number): void;
    
        /**
         * Stops the broadcast.
         */
        StopBroadcasting(): void;
    }
    
    export interface BroadcastStatus {
        broadcastid: string;
        nViewers: number;
        nRequests: number;
        bIsBroadcasting: boolean;
        bIsRecordingDesktop: boolean;
        eBroadcastReady: EResult;
        bBroadcastCapable: boolean;
        bMicrophoneEnabled: boolean;
        bMicrophoneActive: boolean;
        nCurrentFPS: number;
        nUploadKbps: number;
    }
    
  • docs/steam-client/Browser.ts1.9 KBe639df8591e8upstream ↗
    import { Unregisterable } from "./shared";
    
    export interface Browser {
        AddWordToDictionary(word: string): void;
    
        ClearAllBrowsingData(): void;
    
        ClearHistory(): void;
    
        CloseDevTools(): void;
    
        GetBrowserID(): Promise<number>;
    
        GetSpellingSuggestions(word: string): string[];
    
        GetSteamBrowserID(): Promise<number>; // 16-bit unsigned integer?
    
        /**
         * Hides the mouse cursor until input.
         */
        HideCursorUntilMouseEvent(): void;
    
        /**
         * yup that's right, clientY and clientX are reversed
         */
        InspectElement(clientY: number, clientX: number): void;
    
        NotifyUserActivation(): void;
    
        OpenDevTools(): void;
    
        /**
         * Pastes the clipboard contents.
         */
        Paste(): void;
    
        /**
         * @note Not available on a created BrowserView.
         * @todo unconfirmed
         */
        RegisterForGestureEvents(callback: (gesture: TouchGesture) => void): Unregisterable;
    
        /**
         * @note Not available on a created BrowserView.
         */
        RegisterForOpenNewTab: Unregisterable;
    
        ReplaceMisspelling(param0: string): void;
    
        /**
         * Restarts the Steam JS context.
         */
        RestartJSContext(): void;
    
        SetBackgroundThrottlingDisabled(value: boolean): void;
    
        SetPendingFilePath(path: string): Promise<boolean>;
    
        SetShouldExitSteamOnBrowserClosed(value: boolean): Promise<void>;
    
        SetTouchGesturesToCancel(gestures: ETouchGesture[]): void;
    
        /**
         * Prompts and downloads a file.
         * @param url The URL of the file to download.
         */
        StartDownload(url: string): void;
    }
    
    export interface TouchGesture {
        eTouchGesture: ETouchGesture;
        x: number;
        y: number;
    }
    
    export enum ETouchGesture {
        None,
        Touch,
        Tap,
        DoubleTap,
        ShortPress,
        LongPress,
        LongTap,
        TwoFingerTap,
        TapCancelled,
        PinchBegin,
        PinchUpdate,
        PinchEnd,
        FlingStart,
        FlingCancelled,
    }
    
  • docs/steam-client/BrowserView/BrowserViewPopup.ts9.2 KB3f30a573b685upstream ↗
    import { ETouchGesture } from "../Browser";
    import { BrowserView } from ".";
    
    export interface BrowserViewPopup {
        /**
         * Blur the popup contents.
         * @param enabled Is the blur enabled?
         * @param useBackgroundColor
         * @param blur
         */
        AddGlass(enabled: boolean, useBackgroundColor: boolean, blur: boolean): void;
    
        /**
         * @returns `true` if you can go backward in history.
         */
        CanGoBackward(): boolean;
    
        /**
         * @returns `true` if you can go forward in history.
         */
        CanGoForward(): boolean;
    
        // alert() i assume
        DialogResponse(param0: boolean): void;
    
        EnableSteamInput(): void;
    
        /**
         * Find a string in the page.
         * @param input The string to find.
         * @param param1
         * @param previous `true` for previous match, `false` for next match.
         */
        FindInPage(input: string, param1: boolean, previous: boolean): void;
    
        /**
         * Get the current popup position. Only updates when using {@link SetBounds}!
         * @returns the window position.
         */
        GetBounds(): BrowserViewBounds;
    
        /**
         * Go back in history.
         */
        GoBack(): void;
    
        /**
         * Go forward in history.
         */
        GoForward(): void;
    
        /**
         * @param command See {@link BrowserViewContextMenu.custom_commands}.
         */
        HandleContextMenuCommand(command: number, param2: BrowserViewContextMenu): void;
    
        /**
         * Load the specified URL.
         * @param url The URL to go to.
         */
        LoadURL(url: string): void;
    
        NotifyUserActivation(): void;
    
        /**
         * Paste the current clipboard selection.
         */
        Paste(): void;
    
        /**
         * @returns a boolean indicating whether the operation was successful. Will
         * always be `false` if there are no listeners created by
         * {@link BrowserView.RegisterForMessageFromParent}.
         */
        PostMessage(message: string, args: string): boolean;
    
        /**
         * Reload the page.
         */
        Reload(): void;
    
        /**
         * Load the specified URL, but don't save history.
         * @param url The URL to go to.
         */
        ReplaceURL(url: string): void;
    
        /**
         * Define blocked protocols, like https, etc.
         * @param protocols The protocols to block, separated by a semicolon.
         */
        SetBlockedProtocols(protocols: string): void;
    
        /**
         * Sets the browser window position.
         * @param x Browser window X position.
         * @param y Browser window Y position.
         * @param width Browser window width.
         * @param height Browser window height.
         */
        SetBounds(x: number, y: number, width: number, height: number): void;
    
        /**
         * Sets the browser window focus state.
         * @param value Is the window focused?
         */
        SetFocus(value: boolean): void;
    
        SetName(browserName: string): void;
    
        /**
         * Registers a callback to be called when a context menu is shown.
         * @param callback The callback function to be called.
         */
        SetShowContextMenuCallback(callback: (data: BrowserViewContextMenu) => void): void;
    
        /**
         * Registers a callback to be called when a steam:// URL is loaded.
         */
        SetSteamURLCallback(callback: (url: string) => void): void;
    
        /**
         * @todo unconfirmed
         */
        SetTouchGesturesToCancel(gestures: ETouchGesture[]): void;
    
        SetVRKeyboardVisibility(value: boolean): void;
    
        SetVisible(value: boolean): void;
    
        SetWindowStackingOrder(value: EWindowStackingOrder): void;
    
        /**
         * Stop the 'find in page' function.
         */
        StopFindInPage(): void;
    
        /**
         * Stop listening for an event.
         * @param event The event to stop listening to.
         * @param callback The callback function to be called.
         */
        off<K extends keyof BrowserViewEventMap>(event: K, callback: BrowserViewEventMap[K]): void;
    
        /**
         * Start listening for an event.
         * @param event The event to start listening to.
         * @param callback The callback function to be called.
         */
        on<K extends keyof BrowserViewEventMap>(event: K, callback: BrowserViewEventMap[K]): void;
    }
    
    interface BrowserViewEventMap {
        /**
         * Fires when an `alert()` dialog appears.
         */
        "alert-dialog": (message: string) => void;
    
        /**
         * Fires when the browser is about to get destroyed.
         */
        "before-close": () => void;
    
        /**
         * Fires when a URL gets blocked.
         * @todo not SetBlockedProtocols, maybe only steam links
         */
        "blocked-request": (blockedURL: string) => void;
    
        /**
         * Fires when {@link BrowserViewPopup.CanGoBackward} or
         * {@link BrowserViewPopup.CanGoForward} state changes.
         */
        "can-go-back-forward-changed": (canGoBackward: boolean, canGoForward: boolean) => void;
    
        /**
         * Fires when a `confirm()` dialog appears.
         */
        "confirm-dialog": (message: string) => void;
    
        /**
         * Fires when the browser's favicon changes.
         */
        "favicon-urls-changed": (faviconURLs: string[]) => void;
    
        /**
         * Fires when 'Find in page' gets its results.
         */
        "find-in-page-results": (results: number, activeResultIndex: number) => void;
    
        /**
         * Fires when the page finishes loading.
         */
        "finished-request": (currentURL: string, previousURL: string) => void;
    
        /**
         * Fires when the browser goes focused or vice versa.
         */
        "focus-changed": (focused: boolean) => void;
    
        /**
         * Fires when the browser goes fullscreen or vice versa.
         */
        "full-screen": (fullscreen: boolean) => void;
    
        /**
         * Fires when history changes occur.
         */
        "history-changed": (history: BrowserViewHistory) => void;
    
        /**
         * Fires when the URL fails to load.
         */
        "load-error": (errorCode: number, errorURL: string, errorDescription: string) => void;
    
        /**
         * Fires when a message gets sent with {@link BrowserView.PostMessageToParent}.
         */
        message: (message: string, args: string, currentURL: string) => void;
    
        "new-tab": (url: string, param1: boolean) => void;
    
        /**
         * Fires when a node gets focused.
         */
        "node-has-focus": (
            /**
             * Same as {@link Element.tagName}, but the value is the element's ID when exists.
             */
            elementIdOrTagName: string,
            /**
             * Same as {@link Element.tagName}.
             */
            elementTag: string,
            /**
             * The `type` attribute of an `<input>` element.
             */
            inputType: string,
            /**
             * @todo Localization token that doesn't seem to exist? (#Web_FormSubmit)
             */
            token: string,
            param4: boolean,
        ) => void;
    
        "page-security": (url: string, pageSecurity: BrowserViewPageSecurity) => void;
    
        /**
         * Fires when the page's `<title>` changes.
         */
        "set-title": (title: string) => void;
    
        /**
         * Fires when the page starts loading.
         */
        "start-loading": (url: string, param1: boolean) => void;
    
        /**
         * Fires when the page starts loading.
         */
        "start-request": (url: string) => void;
    
        /**
         * Fires when "Find in page" gets toggled.
         */
        "toggle-find-in-page": () => void;
    }
    
    export interface BrowserViewBounds {
        x: number;
        y: number;
        width: number;
        height: number;
    }
    
    export interface BrowserViewContextMenu {
        /**
         * Mouse X position inside the browser view.
         */
        coord_x: number;
    
        /**
         * Mouse Y position inside the browser view.
         */
        coord_y: number;
    
        custom_commands: BrowserViewContextMenuCustomCommand[];
    
        /**
         * Bitmask representing edit state. Appears on editable elements like `<input>`, etc.
         * @see {@link EBrowserViewContextMenuEditFlag}
         */
        edit_state_flags?: number;
    
        /**
         * The misspelled word the cursor is on. Appears on an editable element with text.
         */
        misspelled_word?: string;
    
        /**
         * Browser page URL.
         * @todo Appears when there is selected text?
         */
        link_url?: string;
    
        /**
         * Browser page URL.
         */
        page_url: string;
    
        /**
         * Selected text. Appears when there is selected text.
         */
        selection_text?: string;
    
        /**
         * Bitmask representing context menu type.
         * @see {@link EBrowserViewContextMenuTypeFlag}
         */
        type_flags: number;
    
        /**
         * Browser page URL.
         * @todo Appears when there is selected text?
         */
        unfiltered_link_url?: string;
    }
    
    export interface BrowserViewContextMenuCustomCommand {
        id: number;
        label: string;
    }
    
    export enum EBrowserViewContextMenuTypeFlag {
        None,
        Page = 1 << 0,
        Frame = 1 << 1,
        Link = 1 << 2,
        Media = 1 << 3,
        Selection = 1 << 4,
        Editable = 1 << 5,
    }
    
    export enum EBrowserViewContextMenuEditFlag {
        None,
        CanUndo = 1 << 0,
        CanRedo = 1 << 1,
        CanCut = 1 << 2,
        CanCopy = 1 << 3,
        CanPaste = 1 << 4,
        CanDelete = 1 << 5,
        CanSelectAll = 1 << 6,
        CanTranslate = 1 << 7,
    }
    
    export enum EBrowserViewContextMenuCommand {
        Close = -1,
        OpenDevTools = 26500,
        CloseDevTools,
        InspectElement,
        OpenLinkInNewTab,
    }
    
    export enum EWindowStackingOrder {
        Bottom,
        Top,
    }
    
    export interface BrowserViewHistory {
        index: number;
        entries: BrowserViewHistoryEntry[];
    }
    
    export interface BrowserViewHistoryEntry {
        url: string;
    }
    
    export interface BrowserViewPageSecurity {
        bHasCertError: boolean;
        bIsEVCert: boolean;
        bIsSecure: boolean;
        certExpiry: number;
        certName: string;
        issuerName: string;
        nCertBits: number;
    }
    
  • docs/steam-client/BrowserView/index.ts1.5 KBf34d3204ddbdupstream ↗
    import { Unregisterable } from "../shared";
    import { BrowserViewPopup } from "./BrowserViewPopup";
    
    export interface BrowserView {
        /**
         * @note Not available on a created BrowserView.
         */
        Create(options?: BrowserViewCreateOptions): BrowserViewPopup;
    
        /**
         * Like {@link Create}, but:
         *
         * - Lets you create a BrowserView with
         * `window.open()` instead, while still letting you control the BrowserView
         * the same way.
         *
         * @note Not available on a created BrowserView.
         */
        CreatePopup(options?: BrowserViewCreateOptions): {
            /**
             * URL to use with `window.open()`.
             */
            strCreateURL: string;
            browserView: BrowserViewPopup;
        };
    
        /**
         * @note Not available on a created BrowserView.
         */
        Destroy(browserView: BrowserViewPopup): void;
    
        /**
         * @note Only works on a created BrowserView.
         */
        PostMessageToParent(message: string, args: string): void;
    
        /**
         * Register a callback to be called when a message gets sent with
         * {@link BrowserViewPopup.PostMessage}.
         *
         * @note Only available on a created BrowserView.
         */
        RegisterForMessageFromParent(callback: (message: string, args: string) => void): Unregisterable;
    }
    
    export interface BrowserViewCreateOptions {
        bOnlyAllowTrustedPopups?: boolean;
        parentPopupBrowserID?: number;
        /** Initial URL to load. */
        strInitialURL?: string;
        strUserAgentIdentifier?: string;
        strUserAgentOverride?: string;
        strVROverlayKey?: string;
    }
    
  • docs/steam-client/ClientNotifications.ts1.1 KB8a1a73141676upstream ↗
    import { BrowserContext } from "./shared";
    
    export interface ClientNotifications {
        /**
         * Displays a Steam notification.
         * @param notification Notification type.
         * @param options Stringified object of {@link SteamNotificationOptions}.
         * @param callback
         */
        DisplayClientNotification(
            notification: EClientUINotificationType,
            options: string,
            callback: (context: BrowserContext) => void,
        ): void;
    
        /**
         * @param notificationId The ID of the notification to handle.
         * @param handleAction `true` to execute the callback function associated with the notification.
         */
        OnRespondToClientNotification(notificationId: number, handleAction: boolean): void;
    }
    
    export interface SteamNotificationOptions {
        body: string;
        chatroomgroupid?: number;
        chatroomid?: number;
        icon?: string;
        state: string;
        /** A Steam64 ID. */
        steamid: string;
        tag?: string;
        title?: string;
    }
    
    export enum EClientUINotificationType {
        GroupChatMessage = 1,
        FriendChatMessage,
        FriendPersonaState,
    }
    
  • docs/steam-client/Cloud.ts486 Bb357784c1613upstream ↗
    export interface Cloud {
        /**
         * Resolves a synchronization conflict for an app in the cloud.
         * @param appId The ID of the app with the sync conflict.
         * @param keepLocal Whether to keep the local version during conflict resolution.
         */
        ResolveAppSyncConflict(appId: number, keepLocal: boolean): void;
    
        /**
         * Retries syncing an app with the cloud.
         * @param appId The ID of the app to retry syncing.
         */
        RetryAppSync(appId: number): void;
    }
    
  • docs/steam-client/CommunityItems.ts979 B9f2e09450faaupstream ↗
    export interface CommunityItems {
        /*
        DownloadMovie(e) {
                return (0, o.mG)(this, void 0, void 0, (function* () {
                    if (0 != e.movie_webm_local_path.length) return !0;
                    let t = yield SteamClient.CommunityItems.DownloadItemAsset(e.communityitemid, w, e.movie_webm),
                        n = 1 == t.result;
                    if (n) {
                        e.movie_webm_local_path = t.path;
                        let n = [];
                        this.m_startupMovies.forEach((t => {
                            t.movie_webm == e.movie_webm ? n.push(e) : n.push(t)
                        })), this.m_startupMovies = n
                    }
                    return n
                }))
            }
         */
        DownloadItemAsset(communityItemId: string, param1: any, param2: string): any;
    
        GetItemAssetPath(communityItemId: string, param1: any, param2: string): any;
    
        RemoveDownloadedItemAsset(communityItemId: string, param1: any, param2: string): any;
    }
    
  • docs/steam-client/Console.ts1.2 KB8fe52b4e0f56upstream ↗
    import { Unregisterable } from "./shared";
    
    /**
     * Represents the console functionality for executing commands and handling spew output.
     */
    export interface Console {
        /**
         * Executes a console command.
         * @param command The command to execute in the console.
         */
        ExecCommand(command: string): void;
    
        /**
         * Retrieves autocomplete suggestions for a given console command.
         * @param command The console command to provide autocomplete suggestions for.
         * @returns an array of autocomplete suggestions.
         */
        GetAutocompleteSuggestions(command: string): Promise<string[]>;
    
        /**
         * Registers a callback function to receive spew output.
         * @param callback The callback function that will receive spew output.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForSpewOutput(callback: (output: SpewOutput) => void): Unregisterable;
    }
    
    export type SpewType_t = "assert" | "error" | "warning" | "info" | "input";
    
    /**
     * Represents spew output information.
     */
    export interface SpewOutput {
        /**
         * The content of the spew output.
         */
        spew: string;
    
        /**
         * The type or category of the spew output.
         */
        spew_type: SpewType_t;
    }
    
  • docs/steam-client/Customization.ts329 B854b28363917upstream ↗
    export interface Customization {
        GenerateLocalStartupMoviesThumbnails(param0: number): Promise<number>;
    
        //param0: "startupmovies"
        GetDownloadedStartupMovies(param0: string): Promise<StartupMovie[]>;
    
        GetLocalStartupMovies(): Promise<StartupMovie[]>;
    }
    
    export interface StartupMovie {
        strMovieURL: string;
    }
    
  • docs/steam-client/Downloads.ts6.5 KBfbfefa33c523upstream ↗
    import { Unregisterable } from "./shared";
    import { EAppUpdateError } from "./Apps";
    
    /**
     * Represents functions related to managing downloads in Steam.
     */
    export interface Downloads {
        /**
         * Enables or disables all downloads in Steam.
         * @param enable True to enable downloads, false to disable.
         */
        EnableAllDownloads(enable: boolean): void;
    
        /**
         * Moves the update for a specific app down the download queue.
         * @param appId The ID of the application to move.
         */
        MoveAppUpdateDown(appId: number): void;
    
        /**
         * Moves the update for a specific app up the download queue.
         * @param appId The ID of the application to move.
         */
        MoveAppUpdateUp(appId: number): void;
    
        PauseAppUpdate(appId: number): void; // Broken? It seems to be removing it from download list like RemoveFromDownloadList
    
        /**
         * Adds the update for a specific app to the download queue.
         * @param appId The ID of the application to queue.
         */
        QueueAppUpdate(appId: number): void;
    
        /**
         * Registers a callback function to be called when download items change.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForDownloadItems(callback: (isDownloading: boolean, downloadItems: DownloadItem[]) => void): Unregisterable;
    
        /**
         * Registers a callback function to be called when download overview changes.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForDownloadOverview(callback: (overview: DownloadOverview) => void): Unregisterable;
    
        /**
         * Removes the update for a specific app from the download list and places it in the unscheduled list.
         * @param appId The ID of the application to remove.
         */
        RemoveFromDownloadList(appId: number): void;
    
        /**
         * Resumes the update for a specific app in the queue.
         * @param appId The ID of the application to resume.
         */
        ResumeAppUpdate(appId: number): void;
    
        /**
         * Sets an app to launch when its download is complete.
         * @param appId The ID of the application to set.
         */
        SetLaunchOnUpdateComplete(appId: number): void;
    
        /**
         * Sets the queue index for an app in the download queue.
         * @param appId The ID of the application to set the index for.
         * @param index The index to set.
         * @remarks Index of 0 is the current download in progress.
         */
        SetQueueIndex(appId: number, index: number): void;
    
        /**
         * Suspends or resumes download throttling.
         * @param suspend Whether to suspend or resume download throttling.
         */
        SuspendDownloadThrottling(suspend: boolean): void;
    
        /**
         * Suspends or resumes local transfers.
         * @param suspend Whether to suspend or resume local transfers.
         */
        SuspendLanPeerContent(suspend: boolean): void;
    }
    
    export interface DownloadItem {
        /** True if this app is currently downloading */
        active: boolean;
        /** Appid of app */
        appid: number;
        /** Current build ID for the installed app, zero if the app isn't installed yet */
        buildid: number;
        /** True if this update has been completed */
        completed: boolean;
        /** For completed downloads, time of completion, 0 if not completed */
        completed_time: number;
        deferred_time: number;
        /** Bytes already downloaded, sum across all content types */
        downloaded_bytes: number;
        /** If true, game will launch when its download completes successfully */
        launch_on_completion: boolean;
        /** True if this app has been paused by the user or the system */
        paused: boolean;
        /** Queue index, -1 if the item is unqueued */
        queue_index: number;
        /** Build ID that this download is moving towards. This can be the same as buildid.*/
        target_buildid: number;
        /** Total bytes to download, sum across all content types */
        total_bytes: number;
        /**
         * Update error description, when paused and there has been an error.
         * Unlocalized and shouldn't be displayed to the user.
         */
        update_error: string;
        update_result: EAppUpdateError;
        update_type_info: UpdateTypeInfo[];
    }
    
    export interface DownloadOverview {
        /** Set if we are downloading from LAN peer content server */
        lan_peer_hostname: string;
        /** True if all downloads are paused */
        paused: boolean;
        /** True if download throttling has been temporarily suspended for the current download */
        throttling_suspended: boolean;
        /** Appid of currently updating app */
        update_appid: number;
        /** Bytes already downloaded */
        update_bytes_downloaded: number;
        /** Bytes already processed in current phase - resets to zero when update stage changes */
        update_bytes_processed: number;
        /** Bytes already staged */
        update_bytes_staged: number;
        /** Total bytes to download */
        update_bytes_to_download: number;
        /** Total bytes to process in current phase - resets to zero when update stage changes */
        update_bytes_to_process: number;
        /** Total bytes to be staged */
        update_bytes_to_stage: number;
        /** Current disk throughput estimate */
        update_disc_bytes_per_second: number;
        /** True if the current update is an initial install */
        update_is_install: boolean;
        /** True if download and staging sizes are prefetch estimates */
        update_is_prefetch_estimate: boolean;
        /** True if the current update is for shader update */
        update_is_shader: boolean;
        /** True if the client is running in peer content server mode serving other peers */
        update_is_upload: boolean;
        /** True if the current update is for workshop content */
        update_is_workshop: boolean;
        /** Current bandwidth estimate for download */
        update_network_bytes_per_second: number;
        /** Peak bandwidth estimate for download */
        update_peak_network_bytes_per_second: number;
        /** Estimate of remaining time (in seconds) until download completes (not including staging) */
        update_seconds_remaining: number;
        /** Time current update started */
        update_start_time: number;
        update_state: "None" | "Starting" | "Updating" | "Stopping";
    }
    
    export interface UpdateTypeInfo {
        /** True if this content type had an update and it has completed */
        completed_update: boolean;
        /** Bytes already downloaded for this content type */
        downloaded_bytes: number;
        /** True if this content type has or had an update */
        has_update: boolean;
        /** Total bytes to download for this content type */
        total_bytes: number;
    }
    
  • docs/steam-client/FamilySharing.ts644 B2a6bcadf02abupstream ↗
    import { EResult, Unregisterable } from "./shared";
    
    /**
     * Represents functions related to Steam Family Sharing.
     */
    export interface FamilySharing {
        GetAvailableLenders(appId: number): Promise<Lender[]>;
    
        RegisterForKickedBorrower: Unregisterable;
    
        SetPreferredLender(appId: number, param1: number): Promise<EResult>;
    }
    
    interface LenderDLC {
        rtStoreAssetModifyTime: number;
        strHeaderFilename: string;
        strName: string;
        unAppID: number;
    }
    
    export interface Lender {
        /**
         * A Steam64 ID.
         */
        steamid: string;
        appid: number;
        numDlc: number;
        bPreferred: boolean;
        vecDLC: LenderDLC[];
    }
    
  • docs/steam-client/Friends.ts2.1 KB4a1668943822upstream ↗
    import { Unregisterable } from "./shared";
    
    /**
     * Represents functions related to managing friends in Steam.
     */
    export interface Friends {
        /**
         * Adds a user to the friend list.
         * @param steamId The Steam ID of the user to add as a friend.
         * @returns `true` if the friend was added successfully.
         */
        AddFriend(steamId: string): Promise<boolean>;
    
        /**
         * @returns a list of players you recently played with.
         */
        GetCoplayData(): Promise<CoplayData>;
    
        InviteUserToCurrentGame(steam64Id: string, steamIdTarget: string): Promise<boolean>;
    
        /**
         * Invites a user to a specific game.
         * @param steamId The Steam ID of the user to invite.
         * @param appId The ID of the game to invite the user to.
         * @param connectString Additional parameters for the invitation.
         * @returns `true` if the user was invited successfully.
         */
        InviteUserToGame(steamId: string, appId: number, connectString: string): Promise<boolean>;
    
        /**
         * Invites a user to a specific lobby.
         * @returns `true` if the user was invited successfully.
         */
        InviteUserToLobby(steam64Id: string, steamIdTarget: string): Promise<boolean>;
    
        InviteUserToRemotePlayTogetherCurrentGame(steam64Id: string): Promise<boolean>;
    
        RegisterForMultiplayerSessionShareURLChanged(
            appId: number,
            callback: (param0: string, param1: string) => void,
        ): Unregisterable;
    
        RegisterForVoiceChatStatus(callback: (status: VoiceChatStatus) => void): Unregisterable;
    
        /**
         * Removes a user from the friend list.
         * @param steamId The Steam ID of the user to remove from the friend list.
         * @returns `true` if the friend was removed successfully.
         */
        RemoveFriend(steamId: string): Promise<boolean>;
    
        ShowRemotePlayTogetherUI(): void;
    }
    
    export interface CoplayData {
        currentUsers: CoplayUser[];
        recentUsers: CoplayUser[];
    }
    
    export interface CoplayUser {
        accountid: number;
        rtTimePlayed: number;
        appid: number;
    }
    
    export interface VoiceChatStatus {
        bVoiceChatActive: boolean;
        bMicMuted: boolean;
        bOutputMuted: boolean;
    }
    
  • docs/steam-client/FriendSettings.ts2.6 KBf1ba43f0a686upstream ↗
    import { VDFBoolean_t } from "./shared";
    
    /**
     * Represents friend settings and configuration.
     */
    export interface FriendSettings {
        /**
         * Retrieves a list of enabled friend settings features.
         * @returns an array of enabled friend settings features.
         */
        GetEnabledFeatures(): Promise<FriendSettingsFeatureObject[]>;
    
        /**
         * Registers a callback function to be notified of friend settings changes.
         * @param callback The callback function to be called when friend settings change.
         * @remarks The callback receives a JSON object string which may be parsed into {@link FriendSettingsChange}.
         */
        RegisterForSettingsChanges(callback: (settings: string) => void): void;
    
        /**
         * @param details Stringified {@link FriendSettingsChange}.
         */
        SetFriendSettings(details: string): void;
    }
    
    export enum EChatFlashMode {
        Always,
        Minimized,
        Never,
    }
    
    export interface FriendSettingsFeatureObject {
        feature: FriendSettingsFeature_t;
        bEnabled: boolean;
    }
    
    export type FriendSettingsFeature_t =
        | "DoNotDisturb"
        | "FriendsFilter"
        | "LoaderWindowSynchronization"
        | "NewVoiceHotKeyState"
        | "NonFriendMessageHandling"
        | "PersonaNotifications"
        | "ServerVirtualizedMemberLists"
        | "SteamworksChatAPI";
    
    export type FriendSettingsEnabledFeatures<T> = {
        [feature in FriendSettingsFeature_t]: T;
    };
    
    export interface FriendSettingsChange {
        bNotifications_ShowIngame: VDFBoolean_t;
        bNotifications_ShowOnline: VDFBoolean_t;
        bNotifications_ShowMessage: VDFBoolean_t;
        bNotifications_EventsAndAnnouncements: VDFBoolean_t;
        bSounds_PlayIngame: VDFBoolean_t;
        bSounds_PlayOnline: VDFBoolean_t;
        bSounds_PlayMessage: VDFBoolean_t;
        bSounds_EventsAndAnnouncements: VDFBoolean_t;
        bAlwaysNewChatWindow: VDFBoolean_t;
        bForceAlphabeticFriendSorting: VDFBoolean_t;
        nChatFlashMode: EChatFlashMode;
        bRememberOpenChats: VDFBoolean_t;
        bCompactQuickAccess: VDFBoolean_t;
        bCompactFriendsList: VDFBoolean_t;
        bNotifications_ShowChatRoomNotification: VDFBoolean_t;
        bSounds_PlayChatRoomNotification: VDFBoolean_t;
        bHideOfflineFriendsInTagGroups: VDFBoolean_t;
        bHideCategorizedFriends: VDFBoolean_t;
        bCategorizeInGameFriendsByGame: VDFBoolean_t;
        nChatFontSize: number;
        b24HourClock: VDFBoolean_t;
        bDoNotDisturbMode: VDFBoolean_t;
        bDisableEmbedInlining: VDFBoolean_t;
        bSignIntoFriends: VDFBoolean_t;
        bDisableSpellcheck: VDFBoolean_t;
        bDisableRoomEffects: VDFBoolean_t;
        bAnimatedAvatars: VDFBoolean_t;
        featuresEnabled: FriendSettingsEnabledFeatures<VDFBoolean_t>;
    }
    
  • docs/steam-client/GameNotes.ts2.0 KBbf539c03d502upstream ↗
    import { EResult, OperationResponse } from "./shared";
    
    export interface GameNotes {
        /**
         * @returns a boolean indicating whether the operation was successful.
         */
        DeleteImage(param0: string): Promise<boolean>;
    
        /**
         * @returns a boolean indicating whether the operation was successful.
         */
        DeleteNotes(param0: string): Promise<boolean>;
    
        GetNotes(filenameForNotes: string, directoryForNoteImages: string): Promise<Notes>;
    
        GetNotesMetadata(note: string): Promise<NoteMetadata>;
        GetNumNotes(): Promise<number>;
        GetQuota: Promise<NotesQuota>;
    
        IterateNotes(appId: number, length: number): Promise<NoteMetadata[]>;
        ResolveSyncConflicts(param0: boolean): Promise<EResult>;
    
        /**
         * @param notes Escaped JSON array of {@link Note}.
         */
        SaveNotes(filenameForNotes: string, notes: string): Promise<EResult>;
        SyncToClient(): Promise<EResult>;
    
        SyncToServer(): Promise<EResult>;
    
        /**
         * @param mimeType Image MIME type.
         * @param base64 Image contents in base64.
         * @returns an image file name with its extension that's meant to be used as a part of some URL. (todo)
         * @throws OperationResponse if invalid MIME type or unable to parse base64 BUT NOT if it failed.
         */
        UploadImage(imageFileNamePrefix: string, mimeType: string, base64: string): Promise<EResult | OperationResponse>;
    }
    
    export interface Note {
        appid: number;
        id: string;
        /**
         * Note contents in BB code.
         */
        content: string;
        ordinal: number;
        time_created: number;
        time_modified: number;
        title: string;
    }
    
    interface Notes {
        result: EResult;
        /**
         * Escaped JSON array of {@link Note}. Not present if {@link result} is {@link EResult.FileNotFound}.
         */
        notes?: string;
    }
    
    interface NoteMetadata {
        filename: string;
        filesize: number;
        result: EResult;
        timestamp: number;
    }
    
    interface NotesQuota {
        bytes: number;
        bytesAvailable: number;
        numFiles: number;
        numFilesAvailable: number;
    }
    
  • docs/steam-client/GameRecording.ts1.0 KB4c4e32995424upstream ↗
    import type { JsPbMessage, Unregisterable } from "./shared";
    
    export interface GameRecording {
        /**
         * If `data` is deserialized, returns {@link CGameRecording_AudioSessionsChanged_Notification}.
         */
        RegisterForAudioSessionsChanged(callback: (data: ArrayBuffer) => void): Unregisterable;
        SetAudioSessionCaptureState(id: string, name: string, state: boolean): void;
    }
    
    export interface AudioSession {
        id(): string | undefined;
        name(): string | undefined;
        is_system(): boolean | undefined;
        is_muted(): boolean | undefined;
        is_active(): boolean | undefined;
        is_captured(): boolean | undefined;
        recent_peak(): number | undefined;
        is_game(): boolean | undefined;
        is_steam(): boolean | undefined;
        is_saved(): boolean | undefined;
    }
    
    /**
     * @note Taken from https://github.com/SteamDatabase/SteamTracking/blob/master/Protobufs/steammessages_gamerecording_objects.proto
     */
    export interface CGameRecording_AudioSessionsChanged_Notification extends JsPbMessage {
        sessions(): AudioSession[];
    }
    
  • docs/steam-client/GameSessions.ts1.9 KB8b8d99686c83upstream ↗
    import { Unregisterable } from "./shared";
    import { AppAchievements } from "./Apps";
    import { Screenshot } from "./Screenshots";
    
    /**
     * Represents functions related to Steam Game Sessions.
     */
    export interface GameSessions {
        /**
         * Registers a callback function to be called when an achievement notification is received.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForAchievementNotification(callback: (notification: AchievementNotification) => void): Unregisterable;
    
        /**
         * Registers a callback function to be called when an app lifetime notification is received.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForAppLifetimeNotifications(callback: (notification: AppLifetimeNotification) => void): Unregisterable;
    
        /**
         * Registers a callback function to be called when a screenshot notification is received.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForScreenshotNotification(callback: (notification: ScreenshotNotification) => void): Unregisterable;
    }
    
    /**
     * @prop unAppID is not properly set by Steam for non-steam game shortcuts, so it defaults to 0 for them
     */
    interface GameSessionNotificationBase {
        unAppID: number;
    }
    
    export interface AchievementNotification extends GameSessionNotificationBase {
        achievement: AppAchievements;
        nCurrentProgress: number;
        nMaxProgress: number;
    }
    
    export interface AppLifetimeNotification extends GameSessionNotificationBase {
        nInstanceID: number;
        bRunning: boolean;
    }
    
    export interface ScreenshotNotification extends GameSessionNotificationBase {
        details: Screenshot;
        hScreenshot: number;
        strOperation: "deleted" | "written";
    }
    
  • docs/steam-client/index.ts2.9 KB0ec1ff563696upstream ↗
    import { Apps } from "./Apps";
    import { Auth } from "./Auth";
    import { Broadcast } from "./Broadcast";
    import { Browser } from "./Browser";
    import { BrowserView } from "./BrowserView";
    import { ClientNotifications } from "./ClientNotifications";
    import { Cloud } from "./Cloud";
    import { CommunityItems } from "./CommunityItems";
    import { Console } from "./Console";
    import { Customization } from "./Customization";
    import { Downloads } from "./Downloads";
    import { FamilySharing } from "./FamilySharing";
    import { FriendSettings } from "./FriendSettings";
    import { Friends } from "./Friends";
    import { GameNotes } from "./GameNotes";
    import { GameRecording } from "./GameRecording";
    import { GameSessions } from "./GameSessions";
    import { Input } from "./Input";
    import { InstallFolder } from "./InstallFolder";
    import { Installs } from "./Installs";
    import { Messaging } from "./Messaging";
    import { Music } from "./Music";
    import { Notifications } from "./Notifications";
    import { OpenVR } from "./OpenVR";
    import { Overlay } from "./Overlay";
    import { Storage } from "./Storage";
    import { Parental } from "./Parental";
    import { RemotePlay } from "./RemotePlay";
    import { ServerBrowser } from "./ServerBrowser";
    import { Screenshots } from "./Screenshots";
    import { Settings } from "./Settings";
    import { SharedConnection } from "./SharedConnection";
    import { Stats } from "./Stats";
    import { SteamChina } from "./SteamChina";
    import { Streaming } from "./Streaming";
    import { System } from "./System";
    import { UI } from "./UI";
    import { Updates } from "./Updates";
    import { User } from "./User";
    import { WebChat } from "./WebChat";
    import { WebUITransport } from "./WebUITransport";
    import { Window } from "./Window";
    
    export interface SteamClient {
        Apps: Apps;
        Auth: Auth;
        Broadcast: Broadcast;
        Browser: Browser;
        BrowserView: BrowserView;
        ClientNotifications: ClientNotifications;
        Cloud: Cloud;
        CommunityItems: CommunityItems;
        Console: Console;
        Customization: Customization;
        Downloads: Downloads;
        FamilySharing: FamilySharing;
        Friends: Friends;
        FriendSettings: FriendSettings;
        GameNotes: GameNotes;
        GameRecording: GameRecording;
        GameSessions: GameSessions;
        Input: Input;
        InstallFolder: InstallFolder;
        Installs: Installs;
        MachineStorage: Storage;
        Messaging: Messaging;
        Music: Music;
        Notifications: Notifications;
        OpenVR: OpenVR;
        Overlay: Overlay;
        Parental: Parental;
        RemotePlay: RemotePlay;
        RoamingStorage: Storage;
        Screenshots: Screenshots;
        ServerBrowser: ServerBrowser;
        Settings: Settings;
        SharedConnection: SharedConnection;
        Stats: Stats;
        SteamChina: SteamChina;
        Storage: Storage;
        Streaming: Streaming;
        System: System;
        UI: UI;
        URL: URL;
        Updates: Updates;
        User: User;
        WebChat: WebChat;
        WebUITransport: WebUITransport;
        Window: Window;
    }
    
  • docs/steam-client/Input.ts28 KBab1d7b22e967upstream ↗
    import { Unregisterable } from "./shared";
    
    /**
     * Represents functions related to input and controllers in Steam.
     */
    export interface Input {
        CalibrateControllerIMU(controllerIndex: any): any;
    
        CalibrateControllerJoystick(controllerIndex: any): any;
    
        CalibrateControllerTrackpads(controllerIndex: any): any;
    
        CancelGyroSWCalibration(): any;
    
        ClearSelectedConfigForApp(appId: number, controllerIndex: number): any;
    
        CloseDesktopConfigurator: any;
    
        /**
         * Writes text.
         * @param textToWrite The text to write.
         */
        ControllerKeyboardSendText(textToWrite: string): void;
    
        /**
         * Sets a specified key's pressed state.
         * @param key The key index to set the state for.
         * @param state `true` for pressed, `false` otherwise.
         * @example
         * Send paste command:
         * ```
         * SteamClient.Input.ControllerKeyboardSetKeyState(EHIDKeyboardKey.LControl, true);
         * SteamClient.Input.ControllerKeyboardSetKeyState(EHIDKeyboardKey.V, true);
         * SteamClient.Input.ControllerKeyboardSetKeyState(EHIDKeyboardKey.V, false);
         * SteamClient.Input.ControllerKeyboardSetKeyState(EHIDKeyboardKey.LControl, false);
         * ```
         */
        ControllerKeyboardSetKeyState(key: EHIDKeyboardKey, state: boolean): void;
    
        DecrementCloudedControllerConfigsCounter(): any;
    
        DeletePersonalControllerConfiguration(param0: any): any;
    
        //f.Debug("sending to client"), this.SetEditingConfigurationValue(e, t, c.QU, (e => SteamClient.Input.DuplicateControllerConfigurationSourceMode(this.m_unControllerIndex, e))), this.SaveEditingConfiguration(e), this
        DuplicateControllerConfigurationSourceMode(controllerIndex: number, param1: any): any;
    
        EndControllerDeviceSupportFlow(): any;
    
        ExportCurrentControllerConfiguration(
            controllerIndex: number,
            appId: number,
            param2: number,
            title: string,
            description: string,
            param5: string,
        ): Promise<any>;
    
        ForceConfiguratorFocus(param0: boolean): any;
    
        ForceSimpleHapticEvent(param0: number, param1: number, param2: number, param3: number, param4: number): any;
    
        FreeControllerConfig(m_ChordSummaryConfiguration: any): any;
    
        GetConfigForAppAndController(appId: number, unControllerIndex: number): any;
    
        /**
         * Retrieves the controller mapping string for the specified controller index.
         * @param unControllerIndex The controller index.
         * @returns the controller mapping string.
         */
        GetControllerMappingString(unControllerIndex: number): Promise<string>;
    
        GetControllerPreviouslySeen(): Promise<number[]>;
    
        GetSteamControllerDongleState(): Promise<boolean>;
    
        GetTouchMenuIconsForApp(appId: number): Promise<any>;
    
        GetXboxDriverInstallState(): Promise<any>; // "{"nResult":0}"
        IdentifyController(controllerIndex: number): any;
    
        InitControllerSounds(): any;
    
        InitializeControllerPersonalizationSettings(controllerIndex: number): any;
    
        ModalKeyboardDismissed(): void;
    
        OpenDesktopConfigurator: any;
    
        PreviewConfigForAppAndController(appId: number, controllerIndex: number, workshopUri: string): any;
    
        PreviewControllerLEDColor(flHue: number, flSaturation: number, flBrightness: number): any;
    
        QueryControllerConfigsForApp(appId: number, controllerIndex: number, param2: boolean): any;
    
        RegisterForActiveControllerChanges: Unregisterable; // {"nActiveController":0}
        //param0 - e possibly appid?
        //param1 - some index?
        RegisterForConfigSelectionChanges(callback: (param0: number, param1: number) => void): Unregisterable;
    
        RegisterForControllerAccountChanges: Unregisterable;
    
        RegisterForControllerAnalogInputMessages(callback: (msgs: ControllerAnalogInputMessage[]) => void): Unregisterable;
    
        RegisterForControllerBatteryChanges(callback: any): Unregisterable;
    
        RegisterForControllerCommandMessages(callback: (msg: ControllerCommandMessage) => void): Unregisterable;
    
        /**
         * Registers a callback for changes in controller configuration cloud state.
         * @param callback The callback function for config cloud state changes.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForControllerConfigCloudStateChanges(callback: (state: ControllerConfigCloudState) => void): Unregisterable;
    
        /**
         * Registers a callback for receiving controller configuration info messages (controller layouts query, personal controller layout query).
         * @param callback The callback function for controller config info messages.
         * @returns an object that can be used to unregister the callback.
         * @remarks Do Not Use, this will break the controller layout selection unless you know what you are doing.
         */
        RegisterForControllerConfigInfoMessages(
            callback: (msgs: ControllerConfigInfoMessageList[] | ControllerConfigInfoMessageQuery[]) => void,
        ): Unregisterable;
    
        /**
         * Registers a callback function to be invoked when controller input messages are received.
         * @param callback The callback function to be invoked when controller input messages are received.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForControllerInputMessages(
            callback: (
                controllerIndex: number,
                gamepadButton: ControllerInputGamepadButton,
                isButtonPressed: boolean,
            ) => void,
        ): Unregisterable;
    
        RegisterForControllerListChanges(callback: (controllerListChanges: ControllerInfo[]) => void): Unregisterable;
    
        /**
         * Registers a callback for changes in the controller state (buttons presses, triggers presses, joystick changes etc...).
         * @param callback The callback function for controller state changes.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForControllerStateChanges(callback: (changes: ControllerStateChange[]) => void): Unregisterable;
    
        RegisterForDualSenseUpdateNotification(callback: (m_strDualSenseUpdateProduct: string) => void): Unregisterable;
    
        /**
         * Registers a callback for receiving game keyboard messages (text field popup for inputting text for games when in character creation or etc...).
         * @param callback The callback function for game keyboard messages.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForGameKeyboardMessages(callback: (msg: GameKeyboardMessage) => void): Unregisterable;
    
        RegisterForRemotePlayConfigChanges(callback: () => void): Unregisterable;
    
        //data.appId, data.ulConfigId
        RegisterForShowControllerLayoutPreviewMessages(callback: (data: any) => void): Unregisterable;
    
        /*
                onTouchMenuInput(e) {
                for (let t = 0; t < e.length; t++) {
                    const n = this.TouchMenuGetKey(e[t]), o = this.m_mapActiveTouchMenus.get(n);
                    void 0 !== o && o.updateTouchMenuState(e[t])
                }
            }
         */
        RegisterForTouchMenuInputMessages(callback: (inputs: number[]) => void): Unregisterable;
    
        RegisterForTouchMenuMessages(callback: (msg: TouchMenuMessage) => void): Unregisterable;
    
        //param0 - index?
        RegisterForUIVisualization(param0: any, param1: any, param2: any): Unregisterable;
    
        RegisterForUnboundControllerListChanges(callback: (m_unboundControllerList: any) => void): Unregisterable; // param0 is an array
    
        /*
            OnDismissKeyboardMessage(e) {
                this.m_WindowStore.SteamUIWindows.forEach((e => e.VirtualKeyboardManager.SetVirtualKeyboardHidden(e.BrowserWindow)))
            }
         */
        RegisterForUserDismissKeyboardMessages(callback: (param0: any) => void): Unregisterable;
    
        RegisterForUserKeyboardMessages: Unregisterable;
    
        RequestGyroActive(controllerIndex: number, param1: boolean): any;
    
        RequestRemotePlayControllerConfigs(param0: any): any;
    
        ResetControllerBindings(param0: any): any;
    
        ResolveCloudedControllerConfigConflict(param0: any): any;
    
        RestoreControllerPersonalizationSettings(controllerIndex: number): any;
    
        SaveControllerCalibration(controllerIndex: number): any;
    
        SaveControllerPersonalizationSettings(param0: any): any;
    
        SaveControllerSounds: any;
    
        SaveEditingControllerConfiguration(controllerIndex: number, sharedConfig: boolean): any;
    
        //this.SetEditingConfigurationValue(e, t, c.sL, (e => SteamClient.Input.SetControllerConfigurationModeShiftBinding(this.m_unControllerIndex, e)))
        SetControllerConfigurationModeShiftBinding(controllerIndex: number, param1: any): any;
    
        SetControllerHapticSetting(controllerIndex: number, eHapticSetting: any): any;
    
        SetControllerMappingString(mapping: string): void;
    
        SetControllerName(controllerIndex: number, controllerName: string): any;
    
        SetControllerNintendoLayoutSetting: any;
        SetControllerPersonalizationName: any;
    
        //param0 - nLStickDeadzone, bSWAntiDrift, nRHapticStrength, flRPadPressureCurve
        /*
                    SteamClient.Input.SetControllerPersonalizationSetting("nLStickDeadzone", e.nLStickDeadzone),
                    SteamClient.Input.SetControllerPersonalizationSetting("nRStickDeadzone", e.nRStickDeadzone),
                    SteamClient.Input.SetControllerPersonalizationSetting("bSWAntiDrift", e.bSWAntiDrift ? 1 : 0),
                    SteamClient.Input.SetControllerPersonalizationSetting("nLHapticStrength", e.nLHapticStrength),
                    SteamClient.Input.SetControllerPersonalizationSetting("nRHapticStrength", e.nRHapticStrength),
                    SteamClient.Input.SetControllerPersonalizationSetting("flLPadPressureCurve", 100 * e.flLPadPressureCurve),
                    SteamClient.Input.SetControllerPersonalizationSetting("flRPadPressureCurve", 100 * e.flRPadPressureCurve),
                    SteamClient.Input.SetControllerPersonalizationSetting("ePlayerSlotLEDSetting", e),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nGyroSampleAngleOffsetX", e.nGyroSampleAngleOffsetX),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.bMomentumEnabled", e.bMomentumEnabled ? 1 : 0),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nMomentumFrictionX", e.nMomentumFrictionX),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nMomentumFrictionY", e.nMomentumFrictionY),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nAccerationLevel", e.nAccerationLevel),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.bInvertX", e.bInvertX ? 1 : 0),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.bInvertY", e.bInvertY ? 1 : 0),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nRotationAngle", e.nRotationAngle),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nTriggerClamping", e.nTriggerClamping),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nTriggerClampingAmount", e.nTriggerClampingAmount),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nGyroEnableButton", e.nGyroEnableButton),
                    SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nGyroEnableButtonBehavior", e.nGyroEnableButtonBehavior),
         */
        SetControllerPersonalizationSetting(param0: string, param1: number): any;
    
        //param0 - flGyroStationaryTolerance, flAccelerometerStationaryTolerance,
        /*
                        SteamClient.Input.SetControllerPersonalizationSettingFloat("GyroPreferenceData.flGyroNaturalSensitivity", e.flGyroNaturalSensitivity),
                        SteamClient.Input.SetControllerPersonalizationSettingFloat("GyroPreferenceData.flGyroXYRatio", e.flGyroXYRatio),
                        SteamClient.Input.SetControllerPersonalizationSettingFloat("GyroPreferenceData.flGyroSpeedDeadzone", e.flGyroSpeedDeadzone),
                        SteamClient.Input.SetControllerPersonalizationSettingFloat("GyroPreferenceData.flGyroPrecisionSpeed", e.flGyroPrecisionSpeed),
                    SteamClient.Input.SetControllerPersonalizationSettingFloat("flGyroStationaryTolerance", e.flGyroStationaryTolerance),
                    SteamClient.Input.SetControllerPersonalizationSettingFloat("flAccelerometerStationaryTolerance", e.flAccelerometerStationaryTolerance),
         */
        SetControllerPersonalizationSettingFloat(param0: string, param1: number): any;
    
        SetControllerRumbleSetting(controllerIndex: number, rumblePreference: EControllerRumbleSetting): any;
    
        SetControllerUseUniversalFaceButtonGlyphs(controllerIndex: number, value: boolean): void;
    
        SetCursorActionset(param0: boolean): any;
    
        SetDualSenseUpdateNotification(param0: boolean): any;
    
        /*
                SetEditingConfigurationValue(e, t, n, o) {
                const a = new r.BinaryWriter;
                n.serializeBinaryToWriter(n.fromObject(t), a);
                const s = a.getResultBase64String();
                f.Debug("SetEditingConfigurationValue serializeBinaryToWriter", (0, i.ZN)(t), s), this.EditingConfigurationWillUpdate(), this.m_updatingEditingConfigurationPromise = o(s).then((t => {
                    if (null == t) return f.Debug("SetEditingConfigurationValue returned nothing."), void (0, i.z)((() => this.UpdateEditingConfiguration(e, this.m_unControllerIndex, this.EditingConfiguration)));
                    const n = c.bE.deserializeBinary(t).toObject();
                    f.Debug("SetEditingConfigurationValue returned controller configuration.", n), this.UpdateEditingConfiguration(e, this.m_unControllerIndex, n), this.m_nEditNumber++, -1 == n.url.indexOf("autosave://") && this.SaveEditingConfiguration(e)
                })).catch((e => {
                    f.Error("SetEditingConfigurationValue fail:", o, l.jt(e.result), e.message), this.m_bIsUpdatingActiveConfiguration = !1
                }))
            }
    
            SetControllerActionSet(e, t) {
                this.SetEditingConfigurationValue(e, t, c.X3, (e => SteamClient.Input.SetEditingControllerConfigurationActionSet(this.m_unControllerIndex, e)))
            }
         */
        SetEditingControllerConfigurationActionSet(controllerIndex: number, param1: any): any;
    
        //this.SetEditingConfigurationValue(e, t, c.io, (e => SteamClient.Input.SetEditingControllerConfigurationInputActivator(this.m_unControllerIndex, e)))
        SetEditingControllerConfigurationInputActivator(controllerIndex: number, param1: any): any;
    
        //this.SetEditingConfigurationValue(e, t, c.tH, (e => SteamClient.Input.SetEditingControllerConfigurationInputActivatorEnabled(this.m_unControllerIndex, e)))
        SetEditingControllerConfigurationInputActivatorEnabled(controllerIndex: number, param1: any): any;
    
        //this.SetEditingConfigurationValue(e, t, c.J2, (e => SteamClient.Input.SetEditingControllerConfigurationInputBinding(this.m_unControllerIndex, e)))
        SetEditingControllerConfigurationInputBinding(controllerIndex: number, param1: any): any;
    
        //this.SetEditingConfigurationValue(e, t, c.Sz, (e => SteamClient.Input.SetEditingControllerConfigurationMiscSetting(this.m_unControllerIndex, e)))
        SetEditingControllerConfigurationMiscSetting(controllerIndex: number, param1: any): any;
    
        //f.Debug("sending to client"), this.SetEditingConfigurationValue(e, t, c.QU, (e => SteamClient.Input.SetEditingControllerConfigurationSourceMode(this.m_unControllerIndex, e)))
        SetEditingControllerConfigurationSourceMode(controllerIndex: number, param1: any): any;
    
        SetGamepadKeyboardText(param0: boolean, param1: string): any;
    
        SetKeyboardActionset(param0: boolean, param1: boolean): any;
    
        /**
         * Sets the mouse position.
         * @param pid 0
         * @param x Mouse X position.
         * @param y Mouse Y position.
         */
        SetMousePosition(pid: number, x: number, y: number): void;
    
        SetSelectedConfigForApp(appId: number, controllerIndex: number, url: string, param3: boolean): any;
    
        SetSteamControllerDonglePairingMode(bEnable: boolean, bSilent: boolean): any;
    
        SetVirtualMenuKeySelected(
            unControllerIndex: number,
            unMenuIndex: number,
            m_controllerMenuActiveMenuItem: number,
        ): any; //
        SetWebBrowserActionset(param0: boolean): any;
    
        SetXboxDriverInstallState(param0: any): any; // state
    
        /**
         * Opens the Steam Input controller settings.
         * This function displays the Steam Input controller settings for configuration.
         */
        ShowControllerSettings(): void;
    
        StandaloneKeyboardDismissed(): any;
    
        StartControllerDeviceSupportFlow(param0: any, param1: any, callback: (param2: any) => void): any;
    
        /*
        this.m_updatingEditingConfigurationPromise = SteamClient.Input.StartEditingControllerConfigurationForAppIDAndControllerIndex(e, t).then((n=>{
                                    const o = c.bE.deserializeBinary(n).toObject();
                                    f.Debug("Loaded controller config for appid", e, n, o),
                                        (0,
                                            i.z)((()=>this.UpdateEditingConfiguration(e, t, o)))
                                }
                            )).catch((n=>{
                                    f.Debug("Loading controller config for appid rejected", e, n),
                                        (0,
                                            i.z)((()=>this.UpdateEditingConfiguration(e, t, null)))
                                }
                            ))
         */
        StartEditingControllerConfigurationForAppIDAndControllerIndex(
            m_appId: number,
            m_unControllerIndex: number,
        ): Promise<any>;
    
        StartGyroSWCalibration(callback: () => void): any;
    
        StopEditingControllerConfiguration(controllerIndex: number): any;
    
        SwapControllerConfigurationSourceModes: any;
    
        //this.SetEditingConfigurationValue(e, t, c.Qb, (e => SteamClient.Input.SwapControllerModeInputBindings(this.m_unControllerIndex, e)))
        SwapControllerModeInputBindings(controllerIndex: number, param1: any): any;
    
        SwapControllerOrder(controllerIndex1: number, controllerIndex2: number): any;
    
        SyncCloudedControllerConfigs(): any;
    
        // type - enum
        /*
        Off - 0, Tick, Click
         */
        TriggerHapticPulse(controllerIndex: number, eHapticType: number, param2: number): any;
    
        TriggerSimpleHapticEvent(
            controllerIndex: number,
            eHapticType: number,
            unIntensity: number,
            ndBGain: number,
            param4: number,
        ): any;
    
        UnregisterForControllerStateChanges(): void;
    
        UnregisterForUIVisualization(controllerIndex: number): any;
    
        UploadChangesForCloudedControllerConfigs(): any;
    }
    
    export enum EHIDKeyboardKey {
        Invalid,
        BeforeFirst = 3,
        A,
        B,
        C,
        D,
        E,
        F,
        G,
        H,
        I,
        J,
        K,
        L,
        M,
        N,
        O,
        P,
        Q,
        R,
        S,
        T,
        U,
        V,
        W,
        X,
        Y,
        Z,
        Key_1,
        Key_2,
        Key_3,
        Key_4,
        Key_5,
        Key_6,
        Key_7,
        Key_8,
        Key_9,
        Key_0,
        Return,
        Escape,
        Backspace,
        Tab,
        Space,
        Dash,
        Equals,
        LeftBracket,
        RightBracket,
        Backslash,
        Unused1,
        Semicolon,
        SingleQuote,
        Backtick,
        Comma,
        Period,
        ForwardSlash,
        CapsLock,
        F1,
        F2,
        F3,
        F4,
        F5,
        F6,
        F7,
        F8,
        F9,
        F10,
        F11,
        F12,
        PrintScreen,
        ScrollLock,
        Break,
        Insert,
        Home,
        PageUp,
        Delete,
        End,
        PageDown,
        RightArrow,
        LeftArrow,
        DownArrow,
        UpArrow,
        NumLock,
        KeypadForwardSlash,
        KeypadAsterisk,
        KeypadDash,
        KeypadPlus,
        KeypadEnter,
        Keypad_1,
        Keypad_2,
        Keypad_3,
        Keypad_4,
        Keypad_5,
        Keypad_6,
        Keypad_7,
        Keypad_8,
        Keypad_9,
        Keypad_0,
        KeypadPeriod,
        LAlt,
        LShift,
        LWin,
        LControl,
        RAlt,
        RShift,
        RWin,
        RControl,
        VolUp,
        VolDown,
        Mute,
        Play,
        Stop,
        Next,
        Prev,
        AfterLast,
    }
    
    export interface ControllerAnalogInputMessage {
        nA: number;
        x: number;
        y: number;
        nC: number;
    }
    
    export interface ControllerCommandMessage {
        /**
         * @todo enum
         */
        eAction: number;
        nControllerIndex: number;
    }
    
    export interface ControllerConfigCloudState {
        bSyncDone: boolean;
        bSyncConflict: boolean;
        bSyncError: boolean;
    }
    
    export interface ControllerConfigInfoMessage {
        appID: number;
    }
    
    export interface ControllerConfigInfoMessageQuery extends ControllerConfigInfoMessage {
        bPersonalQueryDone: boolean;
    }
    
    export interface ControllerConfigInfoMessageList extends ControllerConfigInfoMessage {
        nControllerType: number;
        publishedFileID: string;
        accountID: number;
        Title: string;
        Description: string;
        URL: string;
        timeUpdated: string;
        bOfficial: boolean;
        bProgenitorOfficial: boolean;
        bRecommended: boolean;
        bProgenitorRecommended: boolean;
        bUsesSIAPI: boolean;
        bUsesMouse: boolean;
        bUsesKeyboard: boolean;
        bUsesGamepad: boolean;
        /**
         * @todo unconfirmed
         */
        eExportType: EControllerConfigExportType;
        playtime: string;
        bSelected: boolean;
    }
    
    export enum EControllerConfigExportType {
        Unknown,
        PersonalLocal,
        PersonalCloud,
        Community,
        Template,
        Official,
        OfficialDefault,
    }
    
    export enum EControllerRumbleSetting {
        ControllerPreference,
        Off,
        On,
    }
    
    export enum ControllerInputGamepadButton {
        GAMEPAD_BUTTON_A = 0,
        GAMEPAD_BUTTON_B = 1,
        GAMEPAD_BUTTON_X = 2,
        GAMEPAD_BUTTON_Y = 3,
        GAMEPAD_BUTTON_DPAD_UP = 4,
        GAMEPAD_BUTTON_DPAD_RIGHT = 5,
        GAMEPAD_BUTTON_DPAD_DOWN = 6,
        GAMEPAD_BUTTON_DPAD_LEFT = 7,
        GAMEPAD_BUTTON_MENU = 8,
        GAMEPAD_BUTTON_VIEW = 9,
        GAMEPAD_LEFTPAD_UP = 10,
        GAMEPAD_LEFTPAD_DOWN = 11,
        GAMEPAD_LEFTPAD_LEFT = 12,
        GAMEPAD_LEFTPAD_RIGHT = 13,
        GAMEPAD_LEFTPAD_ANALOG = 14,
        GAMEPAD_RIGHTPAD_UP = 15,
        GAMEPAD_RIGHTPAD_DOWN = 16,
        GAMEPAD_RIGHTPAD_LEFT = 17,
        GAMEPAD_RIGHTPAD_RIGHT = 18,
        GAMEPAD_RIGHTPAD_ANALOG = 19,
        GAMEPAD_LEFTSTICK_UP = 20,
        GAMEPAD_LEFTSTICK_DOWN = 21,
        GAMEPAD_LEFTSTICK_LEFT = 22,
        GAMEPAD_LEFTSTICK_RIGHT = 23,
        GAMEPAD_LEFTSTICK_ANALOG = 24,
        GAMEPAD_LEFTSTICK_CLICK = 25,
        GAMEPAD_LTRIGGER_ANALOG = 26,
        GAMEPAD_RTRIGGER_ANALOG = 27,
        GAMEPAD_BUTTON_LTRIGGER = 28,
        GAMEPAD_BUTTON_RTRIGGER = 29,
        GAMEPAD_BUTTON_LSHOULDER = 30,
        GAMEPAD_BUTTON_RSHOULDER = 31,
        GAMEPAD_BUTTON_LBACK = 32,
        GAMEPAD_BUTTON_RBACK = 33,
        GAMEPAD_BUTTON_GUIDE = 34,
        GAMEPAD_BUTTON_SELECT = 35,
        GAMEPAD_BUTTON_START = 36,
        GAMEPAD_BUTTON_LPAD_CLICKED = 37,
        GAMEPAD_BUTTON_LPAD_TOUCH = 38,
        GAMEPAD_BUTTON_RPAD_CLICKED = 39,
        GAMEPAD_BUTTON_RPAD_TOUCH = 40,
        GAMEPAD_RIGHTSTICK_CLICK = 41,
        GAMEPAD_RIGHTSTICK_TOUCH = 42,
        GAMEPAD_LEFTSTICK_TOUCH = 43,
        GAMEPAD_BUTTON_LBACK_UPPER = 44,
        GAMEPAD_BUTTON_RBACK_UPPER = 45,
        GAMEPAD_BUTTON_LAST = 46,
        GAMEPAD_ANALOG_SCROLL = 47,
        GAMEPAD_ANALOG_LEFT_KEYBOARD_CURSOR = 48,
        GAMEPAD_ANALOG_RIGHT_KEYBOARD_CURSOR = 49,
        GAMEPAD_ANALOG_LAST = 50,
    }
    
    // TODO: Not the actual name, but the enum is only represented in a dropdown
    // options vector, ty valve
    export enum EThirdPartyControllerConfiguration {
        Off,
        DefaultSetting,
        On,
    }
    
    export interface ActiveAccount {
        strActiveAccountID: string;
        strName: string;
        strAvatarHash: string;
    }
    
    export interface ControllerInfo {
        strName: string;
        eControllerType: EControllerType;
        nXInputIndex: number;
        nControllerIndex: number;
        eRumblePreference: EControllerRumbleSetting;
        bWireless: boolean;
        unUniqueID: number;
        unVendorID: number;
        unProductID: number;
        /** Bitmask */
        unCapabilities: number;
        strFirmwareBuildTime: string;
        strSerialNumber: string;
        strChipID: string;
        nLEDColorR: number;
        nLEDColorG: number;
        nLEDColorB: number;
        flLEDBrightness: number;
        flLEDSaturation: number;
        nTurnOnSound: number;
        nTurnOffSound: number;
        nLStickDeadzone: number;
        nRStickDeadzone: number;
        nLHapticStrength: number;
        nRHapticStrength: number;
        flLPadPressureCurve: number;
        flRPadPressureCurve: number;
        bHaptics: boolean;
        bSWAntiDrift: boolean;
        flGyroStationaryTolerance: number;
        flAccelerometerStationaryTolerance: number;
        bRemoteDevice: boolean;
        bNintendoLayout: boolean;
        bUseReversedLayout: boolean;
        ActiveAccount: ActiveAccount | undefined;
        vecAltAccounts: any[]; // The type for this property might need to be more specific based on the actual data structure
    }
    
    export enum EControllerType {
        None = -1,
        Unknown,
        UnknownSteamController,
        SteamController, // Codename Gordon
        SteamControllerV2, // Codename Headcrab
        SteamControllerNeptune, // Steam Deck
        FrontPanelBoard = 20,
        Generic = 30,
        XBox360Controller,
        XBoxOneController,
        PS3Controller,
        PS4Controller,
        WiiController,
        AppleController,
        AndroidController,
        SwitchProController,
        SwitchJoyConLeft,
        SwitchJoyConRight,
        SwitchJoyConPair,
        SwitchProGenericInputOnlyController,
        MobileTouch,
        SwitchProXInputSwitchController,
        PS5Controller,
        XboxEliteController,
        LastController, // Unverified
        PS5EdgeController,
        GenericKeyboard = 400,
        GenericMouse = 800,
    }
    
    export interface ControllerStateChange {
        unControllerIndex: number;
        unPacketNum: number;
        /**
         * Bitmask representing pressed upper buttons.
         * - Bit 0-8: Unknown (@todo Please provide more details if known)
         * - Bit 9: L4
         * - Bit 10: R4
         * - Bit 11-13: Unknown (@todo Please provide more details if known)
         * - Bit 14: Left Joystick Touch
         * - Bit 15: Right Joystick Touch
         * - Bit 16-17: Unknown (@todo Please provide more details if known)
         * - Bit 18: Quick Access Menu
         */
        ulUpperButtons: number;
        /**
         * Bitmask representing pressed buttons.
         * - Bit 0: R2
         * - Bit 1: L2
         * - Bit 2: R1
         * - Bit 3: L1
         * - Bit 4: Y
         * - Bit 5: B
         * - Bit 6: X
         * - Bit 7: A
         * - Bit 8: D-Pad Up
         * - Bit 9: D-Pad Right
         * - Bit 10: D-Pad Left
         * - Bit 11: D-Pad Down
         * - Bit 12: Select
         * - Bit 13: Steam/Home
         * - Bit 14: Start
         * - Bit 15: L5
         * - Bit 16: R5
         * - Bit 17: Left Touchpad Click
         * - Bit 18: Right Touchpad Click
         * - Bit 19: Left Touchpad Touch
         * - Bit 20: Right Touchpad Touch
         * - Bit 21: Unknown (@todo Please provide more details if known)
         * - Bit 22: L3
         * - Bit 23-25: Unknown (@todo Please provide more details if known)
         * - Bit 26: R3
         * - Bit 27-28: Unknown (@todo Please provide more details if known)
         * - Bit 29: Mute (Dualsense)
         * - Bit 30-31: Unknown (@todo Please provide more details if known)
         */
        ulButtons: number;
        sLeftPadX: number;
        sLeftPadY: number;
        sRightPadX: number;
        sRightPadY: number;
        sCenterPadX: number;
        sCenterPadY: number;
        sLeftStickX: number;
        sLeftStickY: number;
        sRightStickX: number;
        sRightStickY: number;
        sTriggerL: number;
        sTriggerR: number;
        flTrustedGravityVectorX: number;
        flTrustedGravityVectorY: number;
        flTrustedGravityVectorZ: number;
        flSoftwareQuatW: number;
        flSoftwareQuatX: number;
        flSoftwareQuatY: number;
        flSoftwareQuatZ: number;
        flSoftwareGyroDegreesPerSecondPitch: number;
        flSoftwareGyroDegreesPerSecondYaw: number;
        flSoftwareGyroDegreesPerSecondRoll: number;
        flHardwareQuatW: number;
        flHardwareQuatX: number;
        flHardwareQuatY: number;
        flHardwareQuatZ: number;
        flHardwareGyroDegreesPerSecondPitch: number;
        flHardwareGyroDegreesPerSecondYaw: number;
        flHardwareGyroDegreesPerSecondRoll: number;
        flGyroNoiseLength: number;
        flGyroCalibrationProgress: number;
        flGravityVectorX: number;
        flGravityVectorY: number;
        flGravityVectorZ: number;
        flAccelerometerNoiseLength: number;
        sBatteryLevel: number;
        sPressurePadLeft: number;
        sPressurePadRight: number;
        sPressureBumperLeft: number;
        sPressureBumperRight: number;
        unHardwareUpdateInMicrosec: number;
    }
    
    export interface GameKeyboardMessage {
        m_bOpen: boolean;
        nAppID: number;
        m_dwPID: number;
        m_dwOverlayPID: number;
        m_hPipe: number;
        /** @todo enum */
        m_eInputMode: number;
        /** @todo enum */
        m_eLineInputMode: number;
        m_pchDescription: string;
        m_unCharMax: number;
        m_pchExistingText: string;
    }
    
    export interface TouchMenuMessage {
        bHasVirtualMenus: boolean;
        unControllerIndex: number;
        appID: number;
    }
    
  • docs/steam-client/InstallFolder.ts5.5 KB8d1fbeba26a2upstream ↗
    import { Unregisterable } from "./shared";
    import { EAppUpdateError } from "./Apps";
    
    /**
     * Represents functions related to Steam Install Folders.
     */
    export interface InstallFolder {
        /**
         * Adds a Steam Library folder to the Steam client.
         * @param path The path of the Steam Library folder to be added.
         * @returns the index of the added folder.
         */
        AddInstallFolder(path: string): Promise<number>;
    
        /**
         * Opens the file explorer to browse files in a specific Steam Library folder.
         * @param folderIndex The index of the folder to be opened.
         */
        BrowseFilesInFolder(folderIndex: number): void;
    
        /**
         * Cancels the current move operation for moving game content.
         */
        CancelMove(): void;
    
        /**
         * Retrieves a list of installed Steam Library folders.
         * @returns an array of SteamInstallFolder objects.
         */
        GetInstallFolders(): Promise<SteamInstallFolder[]>;
    
        /**
         * Retrieves a list of potential Steam Library folders that can be added.
         * @returns an array of PotentialInstallFolder objects.
         */
        GetPotentialFolders(): Promise<PotentialInstallFolder[]>;
    
        /**
         * Moves the installation folder for a specific app to another Steam Library folder.
         * @param appId The ID of the application to be moved.
         * @param folderIndex The index of the target Steam Library folder.
         */
        MoveInstallFolderForApp(appId: number, folderIndex: number): void;
    
        /**
         * Refreshes the list of installed Steam Library folders.
         */
        RefreshFolders(): void;
    
        /**
         * Registers a callback function to be called when changes occur in Steam Install Folders.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForInstallFolderChanges(callback: (change: FolderChange) => void): Unregisterable;
    
        /**
         * Registers a callback function to be called when moving game content progresses.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForMoveContentProgress(callback: (progress: MoveContentProgress) => void): Unregisterable;
    
        /**
         * Registers a callback function to be called when repairing an install folder is finished.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForRepairFolderFinished(callback: (change: FolderChange) => void): Unregisterable;
    
        /**
         * Removes a Steam Library folder from the Steam client.
         * @param folderIndex The index of the folder to be removed.
         */
        RemoveInstallFolder(folderIndex: number): void;
    
        /**
         * Repairs an installed Steam Library folder.
         * @param folderIndex The index of the folder to be repaired.
         */
        RepairInstallFolder(folderIndex: number): void;
    
        /**
         * Sets a specific Steam Library folder as the default install folder.
         * @param folderIndex The index of the folder to be set as default.
         */
        SetDefaultInstallFolder(folderIndex: number): void;
    
        /**
         * Sets a user-defined label for a specific Steam Library folder.
         * @param folderIndex The index of the folder to be labeled.
         * @param label The label to be assigned to the folder.
         */
        SetFolderLabel(folderIndex: number, label: string): void;
    }
    
    /**
     * Represents information about an installation folder.
     */
    export interface SteamInstallFolder extends PotentialInstallFolder {
        /** Index of the folder. */
        nFolderIndex: number;
        /** Used space in the folder. */
        strUsedSize: string;
        /** Size of DLC storage used in the folder. */
        strDLCSize: string;
        /** Size of workshop storage used in the folder. */
        strWorkshopSize: string;
        /** Size of staged storage used in the folder. */
        strStagedSize: string;
        /** Indicates if the folder is set as the default installation folder. */
        bIsDefaultFolder: boolean;
        /** Indicates if the folder is currently mounted. */
        bIsMounted: boolean;
        /** List of applications installed in the folder. */
        vecApps: AppInfo[];
    }
    
    export interface PotentialInstallFolder {
        /** Path of the folder. */
        strFolderPath: string;
        /** User label for the folder. */
        strUserLabel: string;
        /** Name of the drive where the folder is located. */
        strDriveName: string;
        /** Total capacity of the folder. */
        strCapacity: string;
        /** Available free space in the folder. */
        strFreeSpace: string;
        /** Indicates if the folder is on a fixed drive. */
        bIsFixed: boolean;
    }
    
    /**
     * Represents information about an installed application.
     */
    export interface AppInfo {
        /** ID of the application. */
        nAppID: number;
        /** Name of the application. */
        strAppName: string;
        /** Sorting information for the application. */
        strSortAs: string;
        /** Last played time in Unix Epoch time format. */
        rtLastPlayed: number;
        /** Size of used storage by the application. */
        strUsedSize: string;
        /** Size of DLC storage used by the application. */
        strDLCSize: string;
        /** Size of workshop storage used by the application. */
        strWorkshopSize: string;
        /** Size of staged storage used by the application. */
        strStagedSize: string;
    }
    
    export interface FolderChange {
        folderIndex: number;
    }
    
    export interface MoveContentProgress {
        appid: number;
        eError: EAppUpdateError;
        flProgress: number;
        strBytesMoved: string;
        strTotalBytesToMove: string;
        nFilesMoved: number;
    }
    
  • docs/steam-client/Installs.ts4.1 KBd5c177866088upstream ↗
    import { Unregisterable } from "./shared";
    import { EAppUpdateError } from "./Apps";
    
    /**
     * Represents functions related to managing installs and installation wizards in Steam.
     */
    export interface Installs {
        /**
         * Cancels the installation wizard if it is open.
         */
        CancelInstall(): void;
    
        /**
         * Continues and starts the installation if the wizard is still open.
         */
        ContinueInstall(): void;
    
        /**
         * Retrieves information from the last opened or currently opened installation wizard.
         */
        GetInstallManagerInfo(): Promise<InstallMgrInfo>;
    
        /**
         * Opens the restore from backup installer wizard for a specific app.
         * @param appBackupPath The backup path of the app.
         */
        OpenInstallBackup(appBackupPath: string): void;
    
        /**
         * Opens the installation wizard for specified app IDs.
         * @param appIds An array of app IDs to install.
         */
        OpenInstallWizard(appIds: number[]): void;
    
        /**
         * Opens the uninstall wizard for specified app IDs.
         * @param appIds An array of app IDs to uninstall.
         * @param dontPrompt Whether to *not* prompt the user to uninstall.
         */
        OpenUninstallWizard(appIds: number[], dontPrompt: boolean): void;
    
        RegisterForShowConfirmUninstall: Unregisterable; // Broken? doesn't seem to work
    
        /**
         * Registers a callback function to be called when the "Failed Uninstall" dialog is shown.
         * @param callback The callback function to be called when the dialog is shown.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForShowFailedUninstall(callback: (appId: number, reason: EAppUpdateError) => void): Unregisterable;
    
        /**
         * Registers a callback function to be called when the installation wizard is shown.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForShowInstallWizard(callback: (data: InstallMgrInfo) => void): Unregisterable;
    
        RegisterForShowRegisterCDKey: any;
    
        /**
         * Sets a list of app identifiers for downloads in the installation wizard.
         * @param appIds An array of app IDs to set.
         * @remarks The wizard will not reflect this change immediately, but changing another option will.
         */
        SetAppList(appIds: number[]): void;
    
        /**
         * Sets the options for creating shortcuts in the installation wizard.
         * @param bDesktopShortcut Whether to create a desktop shortcut.
         * @param bSystemMenuShortcut Whether to create a system menu shortcut.
         * @remarks The wizard will not reflect this change immediately, but changing another option will.
         */
        SetCreateShortcuts(bDesktopShortcut: boolean, bSystemMenuShortcut: boolean): void;
    
        /**
         * Sets the install folder for the installation wizard using an install folder index.
         * @param folderIndex The index of the install folder.
         * @remarks The wizard will not reflect this change immediately, but changing another option will.
         */
        SetInstallFolder(folderIndex: number): void;
    }
    
    export interface InstallMgrInfo {
        rgAppIDs: InstallInfoApps[];
        eInstallState: EInstallMgrState;
        nDiskSpaceRequired: number;
        nDiskSpaceAvailable: number;
        nCurrentDisk: number;
        nTotalDisks: number;
        bCanChangeInstallFolder: boolean;
        /**
         * Index of the install folder. -1 if not installed.
         */
        iInstallFolder: number;
        iUnmountedFolder: number;
        currentAppID: number;
        eAppError: EAppUpdateError;
        errorDetail: string;
        bSystemMenuShortcut: boolean;
        bDesktopShortcut: boolean;
        bIsBackupInstall: boolean;
        // device/hostname
        strPeerContentServer: string;
        bPeerContentServerOnline: boolean;
        bPeerContentServerAvailable: boolean;
    }
    
    export interface InstallInfoApps {
        nAppID: number;
        lDiskSpaceRequiredBytes: number;
    }
    
    export enum EInstallMgrState {
        None,
        Setup,
        WaitLicense,
        FreeLicense,
        ShowCDKey,
        WaitAppInfo,
        ShowPassword,
        ShowConfig,
        ShowEULAs,
        CreateApps,
        ReadFromMedia,
        ShowChangeMedia,
        WaitLegacyCDKeys,
        ShowSignup,
        Complete,
        Failed,
        Canceled,
    }
    
  • docs/steam-client/Messaging.ts833 B8cd340d87130upstream ↗
    import { Unregisterable } from "./shared";
    
    export interface Messaging {
        // section - "ContentManagement", "JumpList", "PostToLibrary"
        // seems multipurpose
        RegisterForMessages<T extends string>(
            message: T,
            callback: (message: T, section: string, args: string) => void,
        ): Unregisterable;
    
        /*
        function m(e) {
            SteamClient.Messaging.PostMessage("LibraryCommands", "ShowFriendChatDialog", JSON.stringify({
                steamid: e.persona.m_steamid.ConvertTo64BitString()
            }))
        }
        SteamClient.Messaging.PostMessage("FriendsUI", "AcceptedRemotePlayInvite", JSON.stringify({id: this.appID})) : SteamClient.Messaging.PostMessage("FriendsUI", "AcceptedGameInvite", JSON.stringify({id: this.appID}))
         */
        PostMessage(message: string, section: string, args: string): void;
    }
    
  • docs/steam-client/Music.ts2.4 KBe971346546acupstream ↗
    import { Unregisterable } from "./shared";
    
    /**
     * Represents functions related to controlling music playback in the Steam client.
     */
    export interface Music {
        /**
         * Decreases the music volume by 10%.
         */
        DecreaseVolume(): void;
    
        /**
         * Increases the music volume by 10%.
         */
        IncreaseVolume(): void;
    
        /**
         * Plays the next track in the music playlist.
         */
        PlayNext(): void;
    
        /**
         * Plays the previous track in the music playlist.
         */
        PlayPrevious(): void;
    
        /**
         * Registers a callback function to be called when music playback changes.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForMusicPlaybackChanges(callback: (param0: boolean | MusicTrack) => void): Unregisterable;
    
        /**
         * Registers a callback function to be called when the music playback position changes.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForMusicPlaybackPosition(callback: (position: number) => void): Unregisterable;
    
        /**
         * Sets the playback position of the music track.
         * @param position The position to set in seconds.
         */
        SetPlaybackPosition(position: number): void;
    
        /**
         * Sets the repeat status for music playback.
         * @param status The repeat status.
         */
        SetPlayingRepeatStatus(status: EMusicPlayingRepeatStatus): void;
    
        /**
         * Sets the shuffle status for music playback.
         * @param value True to enable shuffle, false to disable shuffle.
         */
        SetPlayingShuffled(value: boolean): void;
    
        /**
         * Sets the volume for music playback.
         * @param volume The volume level to set.
         * @remarks Ranges from 0 to 100.
         */
        SetVolume(volume: number): void;
    
        /**
         * Toggles the mute state of the music volume.
         */
        ToggleMuteVolume(): void;
    
        /**
         * Toggles between play and pause for music playback.
         */
        TogglePlayPause(): void;
    }
    
    export interface MusicTrack {
        uSoundtrackAppId: number;
        ePlaybackStatus: EAudioPlayback;
        eRepeatStatus: EMusicPlayingRepeatStatus;
        bShuffle: boolean;
        nVolume: number;
        nActiveTrack: number;
        nLengthInMsec: number;
    }
    
    export enum EAudioPlayback {
        Undefined,
        Playing,
        Paused,
        Idle,
    }
    
    export enum EMusicPlayingRepeatStatus {
        None,
        All,
        Once,
        Max,
    }
    
  • docs/steam-client/Notifications.ts8.0 KBea1531b0d89bupstream ↗
    import { JsPbMessage, Unregisterable } from "./shared";
    
    /**
     * Everything is taken from here:
     * https://github.com/SteamDatabase/SteamTracking/blob/master/Protobufs/steammessages_clientnotificationtypes.proto
     */
    export interface Notifications {
        /**
         * If `data` is deserialized, returns one of the following here: {@link Notifications}
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForNotifications(
            callback: (notificationIndex: number, type: EClientNotificationType, data: ArrayBuffer) => void,
        ): Unregisterable;
    }
    
    export enum EClientNotificationType {
        Invalid,
        DownloadComplete,
        FriendInvite,
        FriendInGame,
        FriendOnline,
        Achievement,
        LowBattery,
        SystemUpdate,
        FriendMessage,
        GroupChatMessage,
        FriendInviteRollup,
        FamilySharingDeviceAuthorizationChanged,
        FamilySharingStopPlaying,
        FamilySharingLibraryAvailable,
        Screenshot,
        CloudSyncFailure,
        CloudSyncConflict,
        IncomingVoiceChat,
        ClaimSteamDeckRewards,
        GiftReceived,
        ItemAnnouncement,
        HardwareSurvey,
        LowDiskSpace,
        BatteryTemperature,
        DockUnsupportedFirmware,
        PeerContentUpload,
        CannotReadControllerGuideButton,
        Comment,
        Wishlist,
        TradeOffer,
        AsyncGame,
        General,
        HelpRequest,
        OverlaySplashScreen,
        BroadcastAvailableToWatch,
        TimedTrialRemaining,
        LoginRefresh,
        MajorSale,
        TimerExpired,
        ModeratorMsg,
        SteamInputActionSetChanged,
        RemoteClientConnection,
        RemoteClientStartStream,
        StreamingClientConnection,
        FamilyInvite,
        PlaytimeWarning,
        FamilyPurchaseRequest,
        FamilyPurchaseRequestResponse,
        ParentalFeatureRequest,
        ParentalPlaytimeRequest,
        GameRecordingError,
        ParentalFeatureResponse,
        ParentalPlaytimeResponse,
        RequestedGameAdded,
        ClipDownloaded,
        GameRecordingStart,
        GameRecordingStop,
        GameRecordingUserMarkerAdded,
        GameRecordingInstantClip,
    }
    
    export enum ESystemUpdateNotificationType {
        Invalid,
        Available,
        NeedsRestart,
    }
    
    export enum EGameRecordingErrorType {
        General = 1,
        LowDiskSpace,
    }
    
    export interface ClientNotificationGroupChatMessage extends JsPbMessage {
        tag(): string;
    
        /** A Steam64 ID. */
        steamid_sender(): string;
    
        chat_group_id(): string;
    
        chat_id(): string;
    
        title(): string;
    
        body(): string;
    
        rawbody(): string;
    
        icon(): string;
    
        notificationid(): number;
    }
    
    export interface ClientNotificationFriendMessage extends JsPbMessage {
        body(): string;
    
        icon(): string;
    
        notificationid(): number;
    
        response_steamurl(): string;
    
        /** A Steam64 ID. */
        steamid(): string;
    
        tag(): string;
    
        title(): string;
    }
    
    export interface ClientNotificationCloudSyncFailure extends JsPbMessage {
        appid(): number;
    }
    
    export interface ClientNotificationCloudSyncConflict extends JsPbMessage {
        appid(): number;
    }
    
    export interface ClientNotificationScreenshot extends JsPbMessage {
        screenshot_handle(): string;
        description(): string;
        local_url(): string;
    }
    
    export interface ClientNotificationDownloadCompleted extends JsPbMessage {
        appid(): number;
        dlc_appid(): number;
    }
    
    export interface ClientNotificationFriendInvite extends JsPbMessage {
        steamid(): number;
    }
    
    export interface ClientNotificationFriendInviteRollup extends JsPbMessage {
        new_invite_count(): number;
    }
    
    export interface ClientNotificationFriendInGame extends JsPbMessage {
        steamid(): number;
        game_name(): string;
    }
    
    export interface ClientNotificationFriendOnline extends JsPbMessage {
        steamid(): number;
    }
    
    export interface ClientNotificationAchievement extends JsPbMessage {
        achievement_id(): string;
        appid(): number;
        name(): string;
        description(): string;
        image_url(): string;
        achieved(): boolean;
        rtime_unlocked(): number;
        min_progress(): number;
        current_progress(): number;
        max_progress(): number;
        global_achieved_pct(): number;
    }
    
    export interface ClientNotificationLowBattery extends JsPbMessage {
        pct_remaining(): number;
    }
    
    export interface ClientNotificationSystemUpdate extends JsPbMessage {
        type(): ESystemUpdateNotificationType;
    }
    
    export interface ClientNotificationFriendMessage extends JsPbMessage {
        tag(): string;
        steamid(): string;
        title(): string;
        body(): string;
        icon(): string;
        notificationid(): number;
        response_steamurl(): string;
    }
    
    export interface ClientNotificationGroupChatMessage extends JsPbMessage {
        tag(): string;
        steamid_sender(): string;
        chat_group_id(): string;
        chat_id(): string;
        title(): string;
        body(): string;
        rawbody(): string;
        icon(): string;
        notificationid(): number;
    }
    
    export interface ClientNotificationFamilySharingDeviceAuthorizationChanged extends JsPbMessage {
        accountid_owner(): number;
        authorized(): boolean;
    }
    
    export interface ClientNotificationFamilySharingStopPlaying extends JsPbMessage {
        accountid_owner(): number;
        seconds_remaining(): number;
        appid(): number;
    }
    
    export interface ClientNotificationFamilySharingLibraryAvailable extends JsPbMessage {
        accountid_owner(): number;
    }
    
    export interface ClientNotificationIncomingVoiceChat extends JsPbMessage {
        steamid(): number;
    }
    
    export interface ClientNotificationClaimSteamDeckRewards extends JsPbMessage {}
    
    export interface ClientNotificationGiftReceived extends JsPbMessage {
        sender_name(): string;
    }
    
    export interface ClientNotificationItemAnnouncement extends JsPbMessage {
        new_item_count(): number;
        new_backpack_items(): boolean;
    }
    
    export interface ClientNotificationHardwareSurveyPending extends JsPbMessage {}
    
    export interface ClientNotificationLowDiskSpace extends JsPbMessage {
        folder_index(): number;
    }
    
    export interface ClientNotificationBatteryTemperature extends JsPbMessage {
        temperature(): number;
        notification_type(): string;
    }
    
    export interface ClientNotificationDockUnsupportedFirmware extends JsPbMessage {}
    
    export interface ClientNotificationPeerContentUpload extends JsPbMessage {
        appid(): number;
        peer_name(): string;
    }
    
    export interface ClientNotificationCannotReadControllerGuideButton extends JsPbMessage {
        controller_index(): number;
    }
    
    export interface ClientNotificationOverlaySplashScreen extends JsPbMessage {}
    
    export interface ClientNotificationBroadcastAvailableToWatch extends JsPbMessage {
        broadcast_permission(): number;
    }
    
    export interface ClientNotificationTimedTrialRemaining extends JsPbMessage {
        appid(): number;
        icon(): string;
        offline(): boolean;
        allowed_seconds(): number;
        played_seconds(): number;
    }
    
    export interface ClientNotificationLoginRefresh extends JsPbMessage {}
    
    export interface ClientNotificationTimerExpired extends JsPbMessage {}
    
    export interface ClientNotificationSteamInputActionSetChanged extends JsPbMessage {
        controller_index(): number;
        action_set_name(): string;
    }
    
    export interface ClientNotificationRemoteClientConnection extends JsPbMessage {
        machine(): string;
        connected(): boolean;
    }
    
    export interface ClientNotificationRemoteClientStartStream extends JsPbMessage {
        machine(): string;
        game_name(): string;
    }
    
    export interface ClientNotificationStreamingClientConnection extends JsPbMessage {
        hostname(): string;
        machine(): string;
        connected(): boolean;
    }
    
    export interface ClientNotificationPlaytimeWarning extends JsPbMessage {
        type(): string;
        playtime_remaining(): number;
    }
    
    export interface ClientNotificationGameRecordingError extends JsPbMessage {
        game_id(): number;
        error_type(): EGameRecordingErrorType;
    }
    
    export interface ClientNotificationGameRecordingStart extends JsPbMessage {
        game_id(): number;
    }
    
    export interface ClientNotificationGameRecordingStop extends JsPbMessage {
        game_id(): number;
        clip_id(): string;
        duration_secs(): number;
    }
    
    export interface ClientNotificationGameRecordingUserMarkerAdded extends JsPbMessage {
        game_id(): number;
    }
    
    export interface CClientNotificationGameRecordingInstantClip extends JsPbMessage {
        game_id(): number;
        clip_id(): string;
        duration_secs(): number;
    }
    
  • docs/steam-client/OpenVR.ts3.2 KB9f297c5616f3upstream ↗
    import { Unregisterable } from "./shared";
    
    export interface OpenVR {
        Device: VRDevice;
        DeviceProperties: DeviceProperties;
    
        /**
         * @throws OperationResponse if mutual capabilities haven't been loaded.
         */
        GetMutualCapabilities(): Promise<any>;
    
        GetWebSecret(): Promise<string>;
    
        InstallVR(): any;
    
        Keyboard: Keyboard;
        PathProperties: PathProperties;
    
        QuitAllVR(): any;
    
        RegisterForButtonPress: Unregisterable;
    
        RegisterForHMDActivityLevelChanged(callback: (m_eHMDActivityLevel: EHMDActivityLevel) => void): Unregisterable;
    
        RegisterForInstallDialog: Unregisterable;
    
        RegisterForStartupErrors(
            callback: (clientError: any, initError: any, initErrorString: string) => void,
        ): Unregisterable;
    
        RegisterForVRHardwareDetected(
            callback: (m_bHMDPresent: any, m_bHMDHardwareDetected: any, m_strHMDName: any) => void,
        ): Unregisterable;
    
        RegisterForVRModeChange(callback: (m_bIsVRRunning: boolean) => void): Unregisterable;
    
        RegisterForVRSceneAppChange(callback: (param0: number) => void): Unregisterable;
    
        SetOverlayInteractionAffordance: any;
    
        StartVR: any;
        TriggerOverlayHapticEffect: any;
        VRNotifications: VRNotifications;
        VROverlay: VROverlay;
    }
    
    export interface VRDevice {
        BIsConnected: any;
        RegisterForDeviceConnectivityChange: Unregisterable;
    
        RegisterForVRDeviceSeenRecently(callback: (m_bVRDeviceSeenRecently: any) => void): Unregisterable;
    }
    
    export interface DeviceProperties {
        GetBoolDeviceProperty: any;
        GetDoubleDeviceProperty: any;
        GetFloatDeviceProperty: any;
        GetInt32DeviceProperty: any;
        GetStringDeviceProperty: any;
        RegisterForDevicePropertyChange: Unregisterable;
    }
    
    export interface Keyboard {
        Hide(): any;
    
        /**
         * {@link EKeyboardFlags} could be useful here
         */
        RegisterForStatus(
            callback: (m_bIsKeyboardOpen: boolean, m_eKeyboardFlags: number, m_sInitialKeyboardText: string) => void,
        ): Unregisterable;
    
        SendDone(): any;
    
        SendText(key: string): any; //???
        Show(): any;
    }
    
    export interface PathProperties {
        GetBoolPathProperty: any;
        GetDoublePathProperty: any;
        GetFloatPathProperty: any;
        GetInt32PathProperty: any;
        GetStringPathProperty: any;
        RegisterForPathPropertyChange: any;
        SetBoolPathProperty: any;
        SetDoublePathProperty: any;
        SetFloatPathProperty: any;
        SetInt32PathProperty: any;
        SetStringPathProperty: any;
    }
    
    export interface VRNotifications {
        HideCustomNotification: any;
        RegisterForNotificationEvent: Unregisterable;
        ShowCustomNotification: any;
    }
    
    export interface VROverlay {
        HideDashboard: any;
    
        IsDashboardVisible(): Promise<boolean>;
    
        RegisterForButtonPress: Unregisterable;
        RegisterForCursorMovement: Unregisterable;
        RegisterForThumbnailChanged: Unregisterable;
        RegisterForVisibilityChanged: Unregisterable;
        ShowDashboard: any;
    
        SwitchToDashboardOverlay(param0: string): void;
    }
    
    export enum EHMDActivityLevel {
        Unknown = -1,
        Idle,
        UserInteraction,
        UserInteraction_Timeout,
        Standby,
        Idle_Timeout,
    }
    
    export enum EKeyboardFlags {
        Minimal = 1 << 0,
        Modal = 1 << 1,
        ShowArrowKeys = 1 << 2,
        HideDoneKey = 1 << 3,
    }
    
  • docs/steam-client/Overlay.ts5.1 KB1c859fb726cbupstream ↗
    import type { EBrowserType, ESteamRealm, EUIComposition, EUIMode, Unregisterable } from "./shared";
    
    export interface Overlay {
        /**
         * Destroys the gamepad UI desktop configurator window if open.
         */
        DestroyGamePadUIDesktopConfiguratorWindow(): void;
    
        GetOverlayBrowserInfo(): Promise<OverlayBrowserInfo[]>;
    
        // steam://gamewebcallback
        HandleGameWebCallback(url: string): void;
    
        /**
         * @param protocol Something like {@link OverlayBrowserProtocols.strScheme}
         */
        HandleProtocolForOverlayBrowser(appId: number, protocol: string): void;
    
        /**
         * Registers a callback function to be called when an overlay is activated from an app.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForActivateOverlayRequests(callback: (request: ActivateOverlayRequest) => void): Unregisterable;
    
        /**
         * Registers a callback function to be called when a microtransaction authorization is requested.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForMicroTxnAuth(
            callback: (appId: number, microTxnId: string, realm: ESteamRealm, microTxnUrl: string) => void,
        ): Unregisterable;
    
        /**
         * Registers a callback function to be called when a microtransaction authorization is dismissed by the user in Steam's authorization page.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForMicroTxnAuthDismiss(callback: (appId: number, microTxnId: string) => void): Unregisterable;
    
        RegisterForNotificationPositionChanged(
            callback: (
                appId: number,
                position: ENotificationPosition,
                horizontalInset: number,
                verticalInset: number,
            ) => void,
        ): Unregisterable;
    
        /**
         * Registers a callback function to be called when an overlay is activated or closed.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForOverlayActivated(
            callback: (overlayProcessPid: number, appId: number, active: boolean, param3: boolean) => void,
        ): Unregisterable;
    
        /**
         * Registers a callback function to be called when the overlay browser protocols change.
         * @param callback The callback function to be called.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForOverlayBrowserProtocols(callback: (browseProtocols: OverlayBrowserProtocols) => void): Unregisterable;
    
        /**
         * Registers **the** callback function to be called when the overlay browser information changes.
         * @param callback The callback function to be called when the overlay browser information changes.
         * @returns an object that can be used to unregister the callback.
         * @remarks Do Not Use, this will break the overlay unless you know what you are doing.
         */
        RegisterOverlayBrowserInfoChanged(callback: () => void): Unregisterable;
    
        SetOverlayState(appId: string, state: EUIComposition): void;
    }
    
    type OverlayRequestDialog_t =
        | "achievements"
        | "asyncnotificationsrequested"
        | "chat"
        | "community"
        | "friendadd"
        | "friendremove"
        | "friendrequestaccept"
        | "friendrequestignore"
        | "friendremove"
        | "jointrade"
        | "leaderboards"
        | "lobbyinvite"
        | "lobbyinviteconnectstring"
        | "officialgamegroup"
        | "requestplaytime"
        | "remoteplaytogether"
        | "remoteplaytogetherinvite"
        | "settings"
        | "stats"
        | "steamid"
        | "store";
    
    // EPosition
    export enum ENotificationPosition {
        TopLeft,
        TopRight,
        BottomLeft,
        BottomRight,
    }
    
    export interface ActivateOverlayRequest {
        /**
         * The app ID that just had an overlay request.
         */
        appid: number;
    
        /**
         * `true` if webpage, and so {@link strDialog} will start with `https://`.
         */
        bWebPage: boolean;
    
        eFlag: EOverlayToStoreFlag;
    
        eWebPageMode: EActivateGameOverlayToWebPageMode;
    
        /**
         * Steam64 ID.
         */
        steamidTarget: string;
    
        /**
         * Game invites string for `Friends.InviteUserToGame`.
         */
        strConnectString: string;
    
        /**
         * Web page URL if starts with `https://`, so cast the type to `string` if it is.
         */
        strDialog: OverlayRequestDialog_t;
    
        /**
         * App ID of the requesting game.
         */
        unRequestingAppID: number;
    }
    
    export interface OverlayBrowserInfo {
        appID: number;
        eBrowserType: EBrowserType;
        eUIMode: EUIMode;
        flDisplayScale?: number;
        gameID: string;
        nBrowserID: number;
        nScreenHeight: number;
        nScreenWidth: number;
        /**
         * The PID of the overlay process.
         */
        unPID: number;
    }
    
    export interface OverlayBrowserProtocols {
        unAppID: number;
        strScheme: string;
        bAdded: boolean;
    }
    
    export enum EActivateGameOverlayToWebPageMode {
        Default,
        Modal,
    }
    
    export enum EOverlayToStoreFlag {
        None,
        AddToCart,
        AddToCartAndShow,
    }
    
  • docs/steam-client/Parental.ts3.6 KBe92e02b43ef9upstream ↗
    import { EResult, Unregisterable } from "./shared";
    
    /**
     * Interface for managing parental control settings.
     */
    export interface Parental {
        /**
         * Locks the parental control settings.
         */
        LockParentalLock(): void;
    
        RegisterForParentalPlaytimeWarnings(callback: (time: number) => void): Unregisterable;
    
        /**
         * Registers a callback function to be invoked when parental settings change.
         * @param callback The callback function to be invoked when parental settings change.
         * @returns an object that can be used to unregister the callback.
         */
        RegisterForParentalSettingsChanges(callback: (settings: ParentalSettings) => void): Unregisterable;
    
        /**
         * Unlocks the parental lock with the provided PIN.
         * @param pin The 4-digit PIN to unlock the parental lock.
         * @returns a number representing the result of the unlock operation.
         */
        UnlockParentalLock(pin: string, param1: boolean): Promise<EResult>;
    }
    
    export interface ParentalSettings {
        ever_enabled: boolean;
        locked: boolean;
        /**
         * If deserialized, returns {@link ParentalSettingsProtoMsg}.
         */
        settings: ArrayBuffer;
        strPlaintextPassword: string;
    }
    
    /**
     * Represents the parental settings and restrictions.
     * @todo This whole thing is unconfirmed as I do not have access to parental
     * stuff and things
     */
    export interface ParentalSettingsProtoMsg {
        steamid?: number;
        applist_base_id?: number;
        applist_base_description?: string;
        /**
         * Base list.
         */
        applist_base: ParentalApp[];
        /**
         * Custom list of allowed applications.
         */
        applist_custom: ParentalApp[];
        /**
         * @todo enum ?
         */
        passwordhashtype?: number;
        salt?: number;
        passwordhash?: number;
        /**
         * Indicates whether parental settings are enabled.
         */
        is_enabled?: boolean;
        /**
         * Bitmask representing enabled features.
         * - Bit 0: Unknown (@todo Please provide more details if known)
         * - Bit 1: Online content & features - Steam Store
         * - Bit 2: Online content & features - Community-generated content
         * - Bit 3: Online content & features - My online profile, screenshots, and achievements
         * - Bit 4: Online content & features - Friends, chat, and groups
         * - Bit 5-11: Unknown (@todo Please provide more details if known)
         * - Bit 12: Library content - 0: Only games I choose, 1: All games
         * @todo {@link EParentalFeature} ?
         */
        enabled_features?: number;
        /**
         * Email for recovery (if applicable).
         */
        recovery_email?: string;
        is_site_license_lock?: boolean;
        temporary_enabled_features?: number;
        rtime_temporary_feature_expiration?: number;
        playtime_restrictions?: ParentalPlaytimeRestrictions;
        temporary_playtime_restrictions?: ParentalTemporaryPlaytimeRestrictions;
        excluded_store_content_descriptors: number[];
        excluded_community_content_descriptors: number[];
        utility_appids: number[];
    }
    
    interface ParentalApp {
        appid: number;
        is_allowed: boolean;
    }
    
    interface ParentalPlaytimeDay {
        allowed_time_windows?: number;
        allowed_daily_minutes?: number;
    }
    
    interface ParentalPlaytimeRestrictions {
        apply_playtime_restrictions?: boolean;
        playtime_days: ParentalPlaytimeDay[];
    }
    
    interface ParentalTemporaryPlaytimeRestrictions {
        restrictions?: ParentalPlaytimeDay;
        rtime_expires?: number;
    }
    
    export enum EParentalFeature {
        Invalid,
        Store,
        Community,
        Profile,
        Friends,
        News,
        Trading,
        Settings,
        Console,
        Browser,
        ParentalSetup,
        Library,
        Test,
        SiteLicense,
        KioskMode,
        Max,
    }
    
  • docs/steam-client/RemotePlay.ts11 KBf74717ff27e2upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/Screenshots.ts4.9 KBeb681d825fdcupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/ServerBrowser.ts11 KB8846ceaf268cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/Settings.ts14 KB4656bee4f176upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/shared.ts5.3 KBfb9488033cb0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/SharedConnection.ts1.5 KB0308f562549eupstream ↗
    import { ESteamRealm, Unregisterable } from "./shared";
    
    /**
     * `hSharedConnection` is the number from {@link AllocateSharedConnection}.
     */
    export interface SharedConnection {
        AllocateSharedConnection(): Promise<number>;
    
        // if no such number, sends this warning:
        // src\clientdll\clientsharedconnection.cpp (154) : m_mapSharedConnections.HasElement( hSharedConnection )
        Close(hSharedConnection: number): void;
    
        RegisterOnBinaryMessageReceived(hSharedConnection: number, callback: (data: ArrayBuffer) => void): Unregisterable;
    
        RegisterOnLogonInfoChanged(hSharedConnection: number, callback: (info: LogonInfo) => void): Unregisterable;
    
        RegisterOnMessageReceived(hSharedConnection: number, callback: (param0: any) => void): Unregisterable;
    
        SendMsg: any;
        SendMsgAndAwaitBinaryResponse: any;
    
        SendMsgAndAwaitResponse(hSharedConnection: number, msg: string): Promise<any>;
    
        SubscribeToClientServiceMethod(hSharedConnection: number, param1: any): any;
    
        SubscribeToEMsg(hSharedConnection: number, param1: any): any;
    }
    
    export interface LogonInfo {
        /** `true` if logged on. */
        bLoggedOn: boolean;
        eUniverse: ESteamRealm;
        /** Account username. Empty if not logged on. */
        strAccountName: string;
        /** URL for community content. */
        strCommunityImagesURL: string;
        /** Account nickname. Empty if not logged on. */
        strPersonaName: string;
        /** Steam64 ID. */
        strSteamid: string;
        /** Country code. */
        strUserCountry: string;
    }
    
  • docs/steam-client/Stats.ts654 Bb1d3c2e31686upstream ↗
    export interface Stats {
        // param0 - AppDetailsReviewSection, Showcases, LibraryReviewSpotlight
        // param1 -
        // AppDetailsReviewSection: PositiveClicked, NegativeClicked, NeutralClicked, PositiveReviewPosted, NegativeReviewPosted, EditClicked, ReviewCanceled
        // LibraryReviewSpotlight: ReviseClicked, PositiveClicked, ReviseCloseClicked, NegativeClicked, PositiveRevisePosted, NegativeRevisePosted, ReviseCanceled, ReviewCanceled, CloseClicked
        // Showcases: Delete, Save-Modify, Save-New
        RecordActivationEvent(param0: string, param1: string): void;
    
        RecordDisplayEvent(param0: boolean, param1: string, param2: string): void;
    }
    
  • docs/steam-client/SteamChina.ts79 Bd23e6c78b7a0upstream ↗
    export interface SteamChina {
        GetCustomLauncherAppID(): Promise<number>;
    }
    
  • docs/steam-client/Storage.ts850 Bf7c7c7442ee9upstream ↗
    import { OperationResponse } from "./shared";
    
    /**
     * SteamClient.MachineStorage affects the "STEAMPATH/config/config.vdf" file.
     * SteamClient.RoamingStorage affects the "STEAMPATH/userdata/STEAMID3/7/remote/sharedconfig.vdf" file.
     * SteamClient.Storage affects the "STEAMPATH/userdata/STEAMID3/config/localconfig.vdf" file.
     */
    export interface Storage {
        DeleteKey(key: string): Promise<OperationResponse | undefined>;
    
        /**
         * @remarks Use {@link SetObject} to set.
         */
        GetJSON(key: string): Promise<OperationResponse | string>;
    
        GetString(key: string): Promise<OperationResponse | string>;
    
        /**
         * @remarks Use {@link SetObject} to get.
         */
        SetObject(key: string, value: object): Promise<OperationResponse | undefined>;
    
        SetString(key: string, value: string): Promise<OperationResponse | undefined>;
    }
    
  • docs/steam-client/Streaming.ts2.6 KB586c6d3806baupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/Audio.ts6.1 KBf918a6847a72upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/AudioDevice.ts2.9 KBf45afe02e895upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/Bluetooth.ts4.6 KBc11035c7bcbfupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/Devkit.ts294 B2899409adc18upstream ↗
    import { Unregisterable } from "../shared";
    
    export interface Devkit {
        DeveloperModeChanged(state: boolean): any;
    
        RegisterForPairingPrompt(callback: (param0: any) => any): Unregisterable;
    
        RespondToPairingPrompt(param0: any, param1: any): any;
    
        SetPairing(param0: any): any;
    }
    
  • docs/steam-client/System/Display.ts363 Bd4a910ceee7cupstream ↗
    import { Unregisterable } from "../shared";
    
    export interface Display {
        EnableUnderscan(param0: boolean): any;
    
        RegisterForBrightnessChanges(callback: (state: BrightnessState) => void): Unregisterable;
    
        SetBrightness(brightness: number): any;
    
        SetUnderscanLevel(param0: any): any;
    }
    
    export interface BrightnessState {
        flBrightness: number;
    }
    
  • docs/steam-client/System/DisplayManager.ts438 B2ab7b6b854a5upstream ↗
    import { Unregisterable } from "../shared";
    
    // CMsgSystemDisplayManagerState, CMsgSystemDisplayManagerSetMode
    export interface DisplayManager {
        ClearModeOverride(displayId: any): any;
    
        GetState: any;
    
        RegisterForStateChanges(callback: () => void): Unregisterable;
    
        SetCompatibilityMode(displayId: any): any;
    
        SetGamescopeInternalResolution(width: number, height: number): any;
    
        SetMode(base64: string): any; //
    }
    
  • docs/steam-client/System/Dock.ts1.0 KB0d293cca7a4bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/index.ts8.9 KB198db613ef64upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/Network/Device.ts502 B01df2764d8b9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/Network/index.ts11 KB917c1453954dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/Perf.ts6.1 KB3ff630260cc0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/Report.ts1.1 KB4edafffe878cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/System/UI.ts983 Bd399c57dcb53upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/UI.ts2.3 KB8e62a5a9422eupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/Updates.ts2.1 KBb554f1bedf88upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/URL.ts4.2 KBe89f73293ab9upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/User.ts7.0 KB8aec572e2b9dupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/WebChat.ts4.6 KBa3749e6396bfupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/WebUITransport.ts578 Be8bfa0a63265upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/steam-client/Window.ts5.7 KB4dd8253a87feupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • docs/SteamClient.ts139 B247ff9022f09upstream ↗
    import { SteamClient } from "./steam-client";
    export * from "./steam-client/shared";
    
    declare global {
        var SteamClient: SteamClient;
    }
    
  • LICENSE6.9 KB0e259d42c996upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • reference/commands.md30 KBf5b774bedcc0upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • reference/decky-plugins.md6.0 KBc36843ee40e1upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • reference/injection.md8.5 KBb8c08c91d6c3upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • reference/launch-options.md12 KBa7b1421f9199upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • reference/remote.md9.9 KB19bea0308dbeupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • reference/steam-client-api.md4.8 KBb44beb5d020cupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • reference/targets.md8.2 KB8fa7c913fa6bupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • reference/troubleshooting.md8.9 KB6251a09082fbupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • steam-debug.mjs115 KB16dabe2a94ccupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/device.mjs2.2 KB7e2814eb0453upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/run-devices.mjs2.0 KBc3a864ab78edupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/skill-lint.mjs18 KB279903750cfaupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

  • test/smoke.mjs63 KB0d8b58813392upstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/kmturley-steam-debug.md

// REPO STATS

7 stars
0 open issues
Last commit: 1mo ago