# steam-debug

Adopt this skill: https://proskills.md/skills/other/kmturley-steam-debug

Page: https://proskills.md/skills/other/kmturley-steam-debug
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: SKILL.md
size: 36414
sha: 70831f4a4d9cfccc88c02bd573e62d6dda777a4c
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/SKILL.md
truncated: true

````text
---
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`
````

## File: README.md
size: 20480
sha: b18aa2f195e640fb6c41f439ea7bc0beb2e35ec6
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/README.md

````text
# 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.
````

## File: .gitattributes
size: 66
sha: dfe0770424b2a19faf507a501ebfc23be8f54e7b
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/.gitattributes

```text
# Auto detect text files and perform LF normalization
* text=auto
```

## File: .gitignore
size: 2160
sha: b6194ac02be704c699e92c783c69126b6db422b7
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/.gitignore

```text
# 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
```

## File: .prettierrc.json
size: 41
sha: e9e3a01c31066d6e56095ffda5c4b1c28e26804a
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/.prettierrc.json

```text
{
  "tabWidth": 4,
  "printWidth": 120
}
```

## File: docs/steam-client/Apps.ts
size: 54677
sha: 444014bcdec7b9f12aaaaeb5bee4655c219393d0
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Apps.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Apps.ts

## File: docs/steam-client/Auth.ts
size: 2432
sha: d1595e56225fa843c1d62872d2dd6e73bf261bb8
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Auth.ts

````text
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,
}
````

## File: docs/steam-client/Broadcast.ts
size: 1832
sha: b3eec561b30d8fd92bdb6fd6bd75e11c58eeff58
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Broadcast.ts

```text
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;
}
```

## File: docs/steam-client/Browser.ts
size: 1902
sha: e639df8591e824cdba9ed329e4543273ade06311
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Browser.ts

```text
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,
}
```

## File: docs/steam-client/BrowserView/BrowserViewPopup.ts
size: 9456
sha: 3f30a573b685163168d65365a3d750915a0d1f42
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/BrowserView/BrowserViewPopup.ts

```text
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;
}
```

## File: docs/steam-client/BrowserView/index.ts
size: 1555
sha: f34d3204ddbdccdd689cc1f02e48c03581ab42cd
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/BrowserView/index.ts

```text
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;
}
```

## File: docs/steam-client/ClientNotifications.ts
size: 1088
sha: 8a1a73141676a2e144c9a16bd1968d296e20fffe
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/ClientNotifications.ts

```text
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,
}
```

## File: docs/steam-client/Cloud.ts
size: 486
sha: b357784c161354127b885cdf757f90253540bd8a
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Cloud.ts

```text
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;
}
```

## File: docs/steam-client/CommunityItems.ts
size: 979
sha: 9f2e09450faa80365ad10ce114c353a0cac9245e
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/CommunityItems.ts

```text
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;
}
```

## File: docs/steam-client/Console.ts
size: 1245
sha: 8fe52b4e0f56d22c357cd33684ba41722d9d7264
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Console.ts

```text
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;
}
```

## File: docs/steam-client/Customization.ts
size: 329
sha: 854b28363917cea2432d1865904a45f5b2ff1e33
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Customization.ts

```text
export interface Customization {
    GenerateLocalStartupMoviesThumbnails(param0: number): Promise<number>;

    //param0: "startupmovies"
    GetDownloadedStartupMovies(param0: string): Promise<StartupMovie[]>;

    GetLocalStartupMovies(): Promise<StartupMovie[]>;
}

export interface StartupMovie {
    strMovieURL: string;
}
```

## File: docs/steam-client/Downloads.ts
size: 6671
sha: fbfefa33c5237086e9db65a877df8e3e54e39a06
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Downloads.ts

```text
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;
}
```

## File: docs/steam-client/FamilySharing.ts
size: 644
sha: 2a6bcadf02abc6e5e3d8eb60c327fd35484b0eba
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/FamilySharing.ts

```text
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[];
}
```

## File: docs/steam-client/Friends.ts
size: 2142
sha: 4a1668943822d891e939aa00a588b1788e2b7eb3
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Friends.ts

```text
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;
}
```

## File: docs/steam-client/FriendSettings.ts
size: 2640
sha: f1ba43f0a686fe36213c0818764f0568a598c59a
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/FriendSettings.ts

```text
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>;
}
```

## File: docs/steam-client/GameNotes.ts
size: 2035
sha: bf539c03d5027d8714c415da104cf1c58936d6f5
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/GameNotes.ts

```text
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;
}
```

## File: docs/steam-client/GameRecording.ts
size: 1047
sha: 4c4e329954242a2c9096b458f8fafae5482a2120
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/GameRecording.ts

```text
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[];
}
```

## File: docs/steam-client/GameSessions.ts
size: 1950
sha: 8b8d99686c83a62dde2daa06194ada034f2620e2
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/GameSessions.ts

```text
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";
}
```

## File: docs/steam-client/index.ts
size: 2924
sha: 0ec1ff5636965180ae2e2f81400e6f24af51cae6
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/index.ts

```text
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;
}
```

## File: docs/steam-client/Input.ts
size: 28751
sha: ab1d7b22e967333acef413cf0ca1d21b72198720
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Input.ts

````text
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;
}
````

## File: docs/steam-client/InstallFolder.ts
size: 5655
sha: 8d1fbeba26a202cde5070350fc0b60ee965f0c26
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/InstallFolder.ts

```text
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;
}
```

## File: docs/steam-client/Installs.ts
size: 4213
sha: d5c17786608807012c649f7e8687eefcd3456d20
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Installs.ts

```text
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,
}
```

## File: docs/steam-client/Messaging.ts
size: 833
sha: 8cd340d8713049965a48ac1b69598ecbd45f8b99
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Messaging.ts

```text
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;
}
```

## File: docs/steam-client/Music.ts
size: 2507
sha: e971346546ac2ae264ec4475452dd7add1548b2a
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Music.ts

```text
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,
}
```

## File: docs/steam-client/Notifications.ts
size: 8237
sha: ea1531b0d89beb8850e1e33d427ca4627c102347
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Notifications.ts

```text
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;
}
```

## File: docs/steam-client/OpenVR.ts
size: 3272
sha: 9f297c5616f3ad7050b570d3c56e91e49de8fac0
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/OpenVR.ts

```text
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,
}
```

## File: docs/steam-client/Overlay.ts
size: 5197
sha: 1c859fb726cbb4dd2465c524a6b0ef0c52a6bce4
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Overlay.ts

```text
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,
}
```

## File: docs/steam-client/Parental.ts
size: 3664
sha: e92e02b43ef911010eb245e33654031f73e7e8cd
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Parental.ts

```text
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,
}
```

## File: docs/steam-client/RemotePlay.ts
size: 10833
sha: f74717ff27e2e88ce2d78bd87756efdcea235e06
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/RemotePlay.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/RemotePlay.ts

## File: docs/steam-client/Screenshots.ts
size: 4979
sha: eb681d825fdc065a5554c0863d2e82956fee804f
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Screenshots.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Screenshots.ts

## File: docs/steam-client/ServerBrowser.ts
size: 11070
sha: 8846ceaf268c94defa2223b8623b789d23448d10
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/ServerBrowser.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/ServerBrowser.ts

## File: docs/steam-client/Settings.ts
size: 14741
sha: 4656bee4f176cb61998dd7a3d084764e525e523b
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Settings.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Settings.ts

## File: docs/steam-client/shared.ts
size: 5430
sha: fb9488033cb043720f66582be19b710813ab93b4
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/shared.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/shared.ts

## File: docs/steam-client/SharedConnection.ts
size: 1514
sha: 0308f562549e6c53b18cb96fc13ab75aa25985a6
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/SharedConnection.ts

```text
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;
}
```

## File: docs/steam-client/Stats.ts
size: 654
sha: b1d3c2e31686ed75d6c7614ac4ab8689581db65e
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Stats.ts

```text
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;
}
```

## File: docs/steam-client/SteamChina.ts
size: 79
sha: d23e6c78b7a0d186048fcf3dea48225fe751c41b
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/SteamChina.ts

```text
export interface SteamChina {
    GetCustomLauncherAppID(): Promise<number>;
}
```

## File: docs/steam-client/Storage.ts
size: 850
sha: f7c7c7442ee9b9838f309b1ddadfe34203564787
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Storage.ts

```text
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>;
}
```

## File: docs/steam-client/Streaming.ts
size: 2650
sha: 586c6d3806ba2d5e1d0940eca826ad0c2d9d7fa9
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Streaming.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Streaming.ts

## File: docs/steam-client/System/Audio.ts
size: 6267
sha: f918a6847a72acaff5b42d8aa5c5b405dad777a3
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Audio.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Audio.ts

## File: docs/steam-client/System/AudioDevice.ts
size: 2993
sha: f45afe02e895aedbd57897908257613b518c01c3
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/AudioDevice.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/AudioDevice.ts

## File: docs/steam-client/System/Bluetooth.ts
size: 4700
sha: c11035c7bcbf2df9ba57ce741cacd0e24ea827e9
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Bluetooth.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Bluetooth.ts

## File: docs/steam-client/System/Devkit.ts
size: 294
sha: 2899409adc186a16465eb68b216ce7716c1e40c6
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Devkit.ts

```text
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;
}
```

## File: docs/steam-client/System/Display.ts
size: 363
sha: d4a910ceee7cd2a98d13fa587f9aa6147c68434d
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Display.ts

```text
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;
}
```

## File: docs/steam-client/System/DisplayManager.ts
size: 438
sha: 2ab7b6b854a5b5c3cd188ee1c6fcde17856a75c0
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/DisplayManager.ts

```text
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; //
}
```

## File: docs/steam-client/System/Dock.ts
size: 1033
sha: 0d293cca7a4bcee9cd790d0c2c219d7f4d35f1c5
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Dock.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Dock.ts

## File: docs/steam-client/System/index.ts
size: 9146
sha: 198db613ef647d4c1bb6a96b70366160dc536979
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/index.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/index.ts

## File: docs/steam-client/System/Network/Device.ts
size: 502
sha: 01df2764d8b919fde9aa99910f2dccf93624d56d
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Network/Device.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Network/Device.ts

## File: docs/steam-client/System/Network/index.ts
size: 11539
sha: 917c1453954d21bdbf22ddc27c9487e256ef0d9c
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Network/index.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Network/index.ts

## File: docs/steam-client/System/Perf.ts
size: 6237
sha: 3ff630260cc005da457477aeff01ed747217b4ca
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Perf.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Perf.ts

## File: docs/steam-client/System/Report.ts
size: 1114
sha: 4edafffe878cc332b89c85c0829a275613120b3e
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Report.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/Report.ts

## File: docs/steam-client/System/UI.ts
size: 983
sha: d399c57dcb538fd87dab3dce567f80268ab01cca
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/UI.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/System/UI.ts

## File: docs/steam-client/UI.ts
size: 2333
sha: 8e62a5a9422e53ecc0f2ff96d52838c560dea2a3
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/UI.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/UI.ts

## File: docs/steam-client/Updates.ts
size: 2182
sha: b554f1bedf88e98933264c472ae57d36852f88ad
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Updates.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Updates.ts

## File: docs/steam-client/URL.ts
size: 4320
sha: e89f73293ab90f1502726b333c98ecdfd5e030c9
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/URL.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/URL.ts

## File: docs/steam-client/User.ts
size: 7174
sha: 8aec572e2b9db8ed52960327d6cabb862beef51a
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/User.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/User.ts

## File: docs/steam-client/WebChat.ts
size: 4720
sha: a3749e6396bffdfabb3eba94615c4daf811f4a97
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/WebChat.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/WebChat.ts

## File: docs/steam-client/WebUITransport.ts
size: 578
sha: e8bfa0a6326523a82949bbed9e40b4f6778835de
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/WebUITransport.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/WebUITransport.ts

## File: docs/steam-client/Window.ts
size: 5813
sha: 4dd8253a87fe6ee4b0c13bb06952a445c2483357
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Window.ts

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/docs/steam-client/Window.ts

## File: docs/SteamClient.ts
size: 139
sha: 247ff9022f09faae9409bc193e629d4fe59fe7f3
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/docs/SteamClient.ts

```text
import { SteamClient } from "./steam-client";
export * from "./steam-client/shared";

declare global {
    var SteamClient: SteamClient;
}
```

## File: LICENSE
size: 7048
sha: 0e259d42c996742e9e3cba14c677129b2c1b6311
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/LICENSE

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/LICENSE

## File: reference/commands.md
size: 31000
sha: f5b774bedcc0ea7589bed2871f29027839a8fd37
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/reference/commands.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/reference/commands.md

## File: reference/decky-plugins.md
size: 6126
sha: c36843ee40e100dc8637f3b771c4ff455a72077d
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/reference/decky-plugins.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/reference/decky-plugins.md

## File: reference/injection.md
size: 8711
sha: b8c08c91d6c35aab6de621bc8862b32dbd25df6c
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/reference/injection.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/reference/injection.md

## File: reference/launch-options.md
size: 12230
sha: a7b1421f9199271d2555a96decb6ce51b1c884c9
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/reference/launch-options.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/reference/launch-options.md

## File: reference/remote.md
size: 10174
sha: 19bea0308dbef87ad45f86f7c0774761b18066d4
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/reference/remote.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/reference/remote.md

## File: reference/steam-client-api.md
size: 4928
sha: b44beb5d020c581e0ff1f96c168a68999a22ac31
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/reference/steam-client-api.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/reference/steam-client-api.md

## File: reference/targets.md
size: 8443
sha: 8fa7c913fa6bee282f5d5ba7e34b8ca936d9fc8e
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/reference/targets.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/reference/targets.md

## File: reference/troubleshooting.md
size: 9077
sha: 6251a09082fb51b8aa508a9b16d69c7435e1b646
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/reference/troubleshooting.md

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/reference/troubleshooting.md

## File: steam-debug.mjs
size: 117889
sha: 16dabe2a94cc98e1c5a95eb77b0ac0f72c7289ce
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/steam-debug.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/steam-debug.mjs

## File: test/device.mjs
size: 2211
sha: 7e2814eb04531b548ca034d5ad3c2ed72ff9f8ba
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/test/device.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/test/device.mjs

## File: test/run-devices.mjs
size: 2047
sha: c3a864ab78ed892a38cbdc73fca6ab98c3b3f652
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/test/run-devices.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/test/run-devices.mjs

## File: test/skill-lint.mjs
size: 18457
sha: 279903750cfa9f0e544e90cb7a0943e3f365d9e0
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/test/skill-lint.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/test/skill-lint.mjs

## File: test/smoke.mjs
size: 64351
sha: 0d8b58813392c51afb10dcda73fabfc7b2c46a3a
upstream: https://github.com/kmturley/steam-debug/blob/HEAD/test/smoke.mjs

Content is not inlined in the catalog. Read the upstream file: https://github.com/kmturley/steam-debug/blob/HEAD/test/smoke.mjs
